主要内容

1. 线程组的使用
2. 切换线程状态的的方法
3. SimpleDataFormat类与多线程的解决办法
4. 处理线程异常的解决办法

线程的状态

线程对象在不同的运行时期有不同的状态，状态信息就存在于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
*/