上篇简单介绍了synchronized关键字的使用，多个线程并发操作一个共享变量时，当一个线程获得对象锁，其余线程就变为阻塞状态。其实，线程除了阻塞状态，还有初始状态、就绪状态、运行状态、终止状态。

线程状态转换

上图就是线程状态转换图，有点山寨（凑合着看吧）。

状态介绍

初始状态

线程被创建，未调用start()方法。

就绪状态

调用了start()，不过还未被OS调度选中执行。

运行状态

调用了start(),且被OS调度选中执行。

阻塞状态

阻塞状态可细分三种，
等待阻塞：线程调用wait()方法，释放了锁，不能自动唤醒，需要其他线程调用notify()、notifyAll()唤醒。
同步阻塞：获取对象同步锁，同步锁被其他线程占用，转为同步阻塞，当线程再次获得锁标记，转为就绪态。
其他阻塞：运行线程执行了sleep()、join()，当sleep()结束，join()等待线程终止，转为就绪状态。

终止状态

线程执行完毕或出现异常退出了run()。

Thread方法

sleep()

public class Test6 implements Runnable{
    @Override
    public void run() {
        for(int i = 0; i < 10; i++){
            try {
                //sleep()必须捕捉异常InterruptedException 
                Thread.sleep(100);
                System.out.println(Thread.currentThread().getName() + "*****" + i);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Test6 a = new Test6();
        Test6 b = new Test6();
        Thread thread1 = new Thread(a, "线程1");
        Thread thread2 = new Thread(b, "线程2");
        //setPriority是设置线程优先级，thread1为最高优先级，thread2最低优先级
        thread1.setPriority(Thread.MAX_PRIORITY);
        thread2.setPriority(Thread.MIN_PRIORITY);
        thread1.start();
        thread2.start();
    }
}

执行结果：

可以看出，在sleep(long mills)会使当前线程进入阻塞状态，执行sleep()的线程在指定时间内不会执行。t1为最高优先级，t2为最低优先级，当t1阻塞的时候，t2能够执行，说明sleep(long mills)可以使低优先级线程有执行机会，同优先级就更有执行机会了。sleep(long mills)不会释放锁标记。

yield()

修改Test6的run()如下,其余不变：

@Override
public void run() {
   for(int i = 0; i < 10; i++){
       Thread.yield();
       System.out.println(Thread.currentThread().getName() + "*****" + i);
   }
}

执行结果：

当t1的优先级为最高级，t2的优先级为最低级，可以看出，t2只能等t1执行完毕后，才有执行的机会，也就是说yield()只能让同等优先级的线程有执行的机会。yield()方法没有任何参数。

join()

/**
 * Created by bxw on 2017/9/19.
 */
public class Test6 implements Runnable{
    @Override
    public void run() {
        for(int i = 0; i < 10; i++){
            System.out.println(Thread.currentThread().getName() + "*****" + i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Test6 a = new Test6();
        Test6 b = new Test6();
        Thread thread1 = new Thread(a, "线程1");
        Thread thread2 = new Thread(b, "线程2");
        thread1.start();
        thread2.start();
    }
}

执行结果：

这个结果是意料之中，比较和谐，t1和t2交替执行。在main()方法中加一句thread.join()试试

public static void main(String[] args) throws InterruptedException {
        Test6 a = new Test6();
        Test6 b = new Test6();
        Thread thread1 = new Thread(a, "线程1");
        Thread thread2 = new Thread(b, "线程2");
        thread1.start();
        thread2.start();
        //新加的join可以放在最后，也可以放在thread1.start()之前
        thread1.join();
}

执行结果：

结果显示，t1执行完毕后，t2才有机会执行。join()方法简通俗点讲就是"插一腿"，可以临时加入一个线程，等这个线程执行完毕，另一个线程继续执行。拿这个例子来说，当主线程碰到t1.join()，t1要加入运行中，获得cpu执行权，cpu执行权就从主线程转到t1手中，等t1执行完后，主线程再恢复到运行中。

Object方法

wait()

在其他线程调用此对象的notify()或notifyAll()方法前，导致当前线程等待。当前线程必须拥有锁标记，执行wait()后，释放锁标记并等待，知道其他线程通过notify()或notifyAll()方法通知在此所标记上的等待线程。

notify()

唤醒在此锁标记上等待的单个线程，如果锁标记上有多个线程，会随机唤醒一个，被唤醒的等待线程并不会立即执行，而是要等到目前拥有锁标记的线程释放锁后，以常规方式与在该锁标记上同步的其他线程重新进行锁标记竞争。

notifyAll()

唤醒在此锁标记上等待的所有线程。

public class Test7 {
    //定义一个锁标记
    private static final String lock = new String("锁");

    private static class Thread1 implements Runnable{
        @Override
        public void run() {
            synchronized (lock){
                System.out.println("thread1开始执行了");
                System.out.println("thread1要wait了");
                try {
                    //wait()会释放锁标记
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("thread1继续执行");
                System.out.println("thread1执行完毕");
            }
        }
    }

    private static class Thread2 implements Runnable{
        @Override
        public void run() {
            //必须和Thread1用同一个锁标记，不然两个对象两个锁就失去意义了
            synchronized (lock){
                System.out.println("thread2开始执行了");
                System.out.println("thread2要notify了");
                lock.notify();
                System.out.println("thread2继续执行");
                System.out.println("thread2执行完毕");
            }
        }
    }

    public static void main(String[] args) {
        Thread1 a = new Thread1();
        Thread2 b = new Thread2();
        Thread thread1 = new Thread(a, "线程1");
        Thread thread2 = new Thread(b, "线程2");
        thread1.start();
        thread2.start();
    }
}

执行结果：

总结

本篇主要介绍了线程的五个状态以及状态之间转换所用到的方法。sleep(long mills)、yield()、join()都是Thread的方法，wait()、notify()、notifyAll()都是Object的方法。sleep和wait的区别：①首先是方法的归属不同，sleep是Thread，wait是Object；②sleep()可以在任何地方使用，wait只能在同步块中使用；③sleep不会释放锁标记，到时间了就从阻塞态转为就绪态，wait需要notify()、notifyAll()唤醒，且重新获得锁标记后才会转为就绪态。

略陈固陋，如有不当之处，欢迎各位看官批评指正！