线程的状态

一、线程状态

NEW     新new出来，还没有执行start方法

RUNNABLE   可运行状态，或者在执行，或者在等待CPU分配时间

BLOCKED   当线程调用wait方法后，线程就进入了阻塞状态，等待其他的线程调用notify方法，将当前线程唤醒，然后去争抢锁，进入可运行状态

WAITING    等待状态，线程调用wait方法或者join方法

TIMED_WAITING  计时等待状态   线程调用wait(long)或者join(long) 

TERMINATED  终止状态   run方法运行完

上面的几种状态是JDK定义的线程状态枚举类中规定的，与平常所说的状态不一样,平常说的阻塞状态就是调用了wait或者sleep，join等方法

模拟BLOCKED

/**
 * 模拟线程的BLOCKED状态，阻塞状态即等待锁
 *
 */
public class ThreadState extends Thread {

    private static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {

        //t1线程
        Thread t1 = new ThreadState();
        t1.start();
        
        // 主线程休眠1秒，等待t1线程启动起来
        Thread.sleep(1000);

        //t2线程
        Thread t2 = new Thread() {
            @Override
            public void run() {
                hello();
            }
        };
        t2.start();

        //主线程休眠2秒,等待t1,t2线程都启动起来
        Thread.sleep(2000);
        System.out.println("t1线程状态 ："+t1.getState()); //t1线程状态 ：RUNNABLE
        System.out.println("t2线程状态: "+t2.getState()); //t2线程状态: BLOCKED
    }

    public static void hello() {
        synchronized (lock) {

        }
    }

    public static void say() {
        synchronized (lock) {
            while (true) {

            }
        }

    }

    @Override
    public void run() {
        say();
    }
}

模拟其他的状态

public class ThreadState {

    public static void main(String[] args) throws InterruptedException {

        // t1线程
        Thread t1 = new Thread() {
            @Override
            public void run() {

                Thread t2 = new Thread() {
                    @Override
                    public void run() {
                        while (true) {

                        }
                    }
                };
                t2.start();
                try {
                    t2.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

//                try {
//                    Thread.sleep(5000);
//                } catch (InterruptedException e) {
//                    // TODO Auto-generated catch block
//                    e.printStackTrace();
//                }
            }

        };
        t1.start();

        Thread.sleep(2000);
        System.out.println("t1线程状态 ：" + t1.getState());
        // t1线程状态 ：TERMINATED
        // t1线程状态 ：RUNNABLE
        // t1线程状态 ：NEW
        // t1线程状态 ：TIMED_WAITING
        // t1线程状态 ：WAITING
    }

}

二、几个方法的比较

1  Thread.sleep(long millis)，一定是当前线程调用此方法，当前线程进入阻塞，但不释放对象锁，millis后线程自动苏醒进入可运行状态。作用：给其它线程执行机会的最佳方式。

2 Thread.yield()，一定是当前线程调用此方法，当前线程放弃获取的cpu时间片，由运行状态变会可运行状态，让OS再次选择线程。作用：让相同优先级的线程轮流执行，但并不保证一定会轮流执行。实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。Thread.yield()不会导致阻塞。

3  t1.join()/t1.join(long millis)，当前线程里调用其它线程t1的join方法，当前线程阻塞，但不释放对象锁，直到线程t1执行完毕或者millis时间到，当前线程进入可运行状态

4  obj.wait()，当前线程调用对象的wait()方法，当前线程释放对象锁，进入等待队列。依靠notify()/notifyAll()唤醒或者wait(long timeout)timeout时间到自动唤醒,，争抢锁然后进入可运行状态

5  obj.notify()唤醒在此对象监视器上等待的单个线程，选择是任意性的。notifyAll()唤醒在此对象监视器上等待的所有线程