线程中wait()、sleep（）、notify（）、yield（）、join的使用

wait（）：线程进入等待状态直到notify唤醒或者notifyAll唤醒。

sleep（）：线程进入睡眠，该线程暂停。

notify（）：唤醒wait队列中的第一个线程，与此对应的notifyAll唤醒wait队列中的所有线程。

yield（）：线程会让出资源，但是并不会让出锁，若果是加锁的代码块，会在该线程完全结束后其他线程才能访问。

join（）：线程插队，在线程1中执行Thread2.join线程1会在线程2结束后才执行。

下面是代码实际效果：

package thread;


/**
 * @author Eden
 * @date 2018/7/27
 */
public class ThreadWaitNotifyJoinTest {
    public static void main(String[] args) {
        Thread test0 = new Thread(new thread1());
        Thread test1 = new Thread(new thread1());
        Thread test2 = new Thread(new thread1());
        Thread test3 = new Thread(new thread1());

        test0.start();
        test1.start();
        test2.start();
        test3.start();
        try {
            test1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private static class thread1 implements Runnable {
        @Override
        public void run() {
            synchronized (ThreadWaitNotifyJoinTest.class) {
                System.out.println(Thread.currentThread().getName() + "执行读操作");
                System.out.println(Thread.currentThread().getName() + "进入等待状态");
                if (Thread.currentThread().getName().equals("Thread-0")) {
                    try {
                        /**
                         * 进入等待状态直到notify唤醒或者notifyall唤醒
                         * */
                        ThreadWaitNotifyJoinTest.class.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else if (Thread.currentThread().getName().equals("Thread-1")) {
                    /**
                     * 线程1进来，唤醒线程0，唤醒操作并不会让出锁，自己执行完才会让出锁
                     * */
                    ThreadWaitNotifyJoinTest.class.notify();
                } else if (Thread.currentThread().getName().equals("Thread-2")){

                    System.out.println(Thread.currentThread().getName() +"不好意思，我是赶时间才插个队");
                }else if (Thread.currentThread().getName().equals("Thread-3")){
                    /**
                     * yield方法让出资源，但并不会让出锁，还是会在线程3执行完后才会执行其他线程
                     * */
                    Thread.yield();
                    System.out.println(Thread.currentThread().getName() + "我让资源不让锁，你们还是得等我释放锁才能继续进行");
                    System.out.println(Thread.currentThread().getName() + "让我休息10秒钟");
                    try {
                        Thread.sleep(10000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName() + "执行结束");
            }
        }
    }


}

执行上面代码的结果如下：

从结果来看，线程0最开始执行由于wait操作进入等待队列没能继续执行，等待着线程1唤醒，线程1又使用了join让线程2插队了，在线程2结束后才能执行线程1然后是线程0.

为什么线程3总是最先执行完成的呢？个人理解为其他的wait 、join等操作都是耗时的，由于线程3不存在这些操作，所以就先获得了锁，其他的就只能等着线程3执行完了。

第一次写博客，如有错误，欢迎指正。