主要内容
- 线程组的使用
- 切换线程状态的的方法
- SimpleDataFormat类与多线程的解决办法
- 处理线程异常的解决办法
线程的状态
线程对象在不同的运行时期有不同的状态，状态信息就存在于State枚举类中。
在调用与线程有关的方法后，会进入不同的线程状态，这些状态之间某些是可双向切换的，比如WAITING和RUNNABLE状态之间就可以循环的双向切换。而有些是单向切换的，比如线程销毁后并不能自动进入RUNNING状态。
public class MyThread extends Thread {
/**
* Constructs MyThread
*
*/
public MyThread() {
System.out.println("构造方法中的状态 ：" + Thread.currentThread().getState());
}
@Override
public void run() {
System.out.println("run方法中的状态：" + Thread.currentThread().getState());
}
}
public class Run {
/**
* NEW
* RUNNABLE
* TERMINATED
* BLOCKED
* WAITING
* TIMED_WAITING
*
* @param args
*/
public static void main(String[] args) {
try {
MyThread t = new MyThread();
System.out.println("main方法中的状态1：" + t.getState());
Thread.sleep(1000);
t.start();
Thread.sleep(1000);
System.out.println("main方法中的状态2：" + t.getState());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/*result:
构造方法中的状态 ：RUNNABLE
main方法中的状态1：NEW
run方法中的状态：RUNNABLE
main方法中的状态2：TERMINATED
*/
TIMED_WAITING状态
线程状态TIMED_WAITING代表线程执行Thread.sleep()方法，呈等待状态，等待时间到达，继续向下运行。
public class MyThread extends Thread {
@Override
public void run() {
System.out.println("begin sleep");
try {
Thread.sleep(10000);
System.out.println(" end sleep");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public class Run {
/**
* Method main
*
*
* @param args
*/
public static void main(String[] args) {
try {
MyThread t = new MyThread();
t.start();
Thread.sleep(1000);
System.out.println("main方法中状态：" + t.getState());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/*result:
begin sleep
main方法中状态：TIMED_WAITING
end sleep
*/
BLOCKED状态
BLOCKED状态出现在某一个线程的等待锁的时候。
public class MyService {
/**
* Method serviceMethod
*
*/
public static synchronized void serviceMethod() {
try {
System.out.println(Thread.currentThread().getName() + " 进入了业务方法");
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public class MyThread1 extends Thread {
@Override
public void run() {
MyService.serviceMethod();
}
}
public class MyThread2 extends Thread {
@Override
public void run() {
MyService.serviceMethod();
}
}
public class Run {
/**
* Method main
*
*
* @param args
*/
public static void main(String[] args) {
MyThread1 t1 = new MyThread1();
t1.setName("A");
t1.start();
MyThread2 t2 = new MyThread2();
t2.setName("B");
t2.start();
System.out.println("main方法中的t2状态：" + t2.getState());
}
}
/*result:
A 进入了业务方法
main方法中的t2状态：RUNNABLE
B 进入了业务方法
*/
/*程序有误*/
线程组
可以吧线程归属到某一个线程组中可以有线程对象，也可以有线程组，组中也可由还有线程组这样类似于树的形式。
线程组的作用是，可以批量的管理线程或线程组对象，有效的对线程组对象进行组织。
线程对象关联线程组：1级关联
所谓一级关联就是父对象中有子对象，但并不创建子孙对象。这种情况经常出现在开发中，比如创建一些线程时，为了有效的对这些线程进行组织管理，通常情况下是创建一个线程组，然后再将部分线程归属到该组中。这样的处理可以对零散的线程对象进行有效的组织与规划。
public class ThreadA extends Thread {
@Override
public void run() {
try {
while (!Thread.currentThread().isInterrupted()) {
System.out.println("ThreadName = " + Thread.currentThread().getName());
Thread.sleep(3000);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public class ThreadB extends Thread {
@Override
public void run() {
try {
while (!Thread.currentThread().isInterrupted()) {
System.out.println("ThreadName = " + Thread.currentThread().getName());
Thread.sleep(3000);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public class Run {
/**
* Method main
*
*
* @param args
*/
public static void main(String[] args) {
ThreadA aRunnable = new ThreadA();
ThreadB bRunnable = new ThreadB();
ThreadGroup group = new ThreadGroup("Tzs线程组");
Thread aThread = new Thread(group, aRunnable);
Thread bThread = new Thread(group, bRunnable);
aThread.start();
bThread.start();
System.out.println("活动的线程数为:" + group.activeCount());
System.out.println("线程组名称为：" + group.getName());
}
}
/*result:
活动的线程数为:2
ThreadName = Thread-3
线程组名称为：Tzs线程组
ThreadName = Thread-2
ThreadName = Thread-3
ThreadName = Thread-2
ThreadName = Thread-2
ThreadName = Thread-3
ThreadName = Thread-2
ThreadName = Thread-3
*/
线程对象关联线程组：多级关联
所谓多级关联就是父对象中有子对象，子对象中在创建子对象，也就是出现子孙对象的效果了。但是此种写法在开发中不常见如果线程树结构设计得非常复杂，反而不利于线程对象的管理。但JDK却提供了支持多级关联的线程结构。
public class Run {
/**
* Method main
*
*
* @param args
*/
public static void main(String[] args) {
ThreadGroup mainGroup = Thread.currentThread().getThreadGroup();
ThreadGroup group = new ThreadGroup(mainGroup, "A");
Runnable runnable = new Runnable() {
@Override
public void run() {
try {
System.out.println("runMethod");
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
Thread newThread = new Thread(group, runnable);
newThread.setName("Z");
newThread.start();
ThreadGroup[] listGroup = new ThreadGroup[Thread.currentThread().getThreadGroup().activeGroupCount()];
Thread.currentThread().getThreadGroup().enumerate(listGroup);
System.out.println("main线程中有多少个子线程组: " + listGroup.length + " 名字为： " + listGroup[0].getName());
Thread[] listThread = new Thread[listGroup[0].activeCount()];
listGroup[0].enumerate(listThread);
System.out.println(listThread[0].getName());
}
}
/*result:
main线程中有多少个子线程组: 1 名字为： A
Z
runMethod
*/
