并发编程之常用操作（等待，通知，join，yeild，sleep）

1、等待（wait）和通知（notify）

JDK提供了两个非常重要的方法：等待wait()方法和通知notify()方法。这2个方法并不是在Thread类中的，而是在Object类中定义的。这意味着所有的对象都可以调用者两个方法。

public final void wait() throws InterruptedException;

public final native void notify();

当在一个对象实例上调用wait()方法后，当前线程就会在这个对象上等待。比如在线程A中，调用了obj.wait()方法，那么线程A就会停止继续执行，转为等待状态，线程A会一直等到其他线程调用obj.notify()方法为止。

如果一个线程调用了object.wait()方法，那么它就会进出object对象的等待队列。这个队列中，可能会有多个线程，因为系统可能运行多个线程同时等待某一个对象。当object.notify()方法被调用时，它就会从这个队列中随机选择一个线程，并将其唤醒。这个选择是不公平的，并不是先等待线程就会优先被选择，这个选择完全是随机的。

除notify()方法外，Object独享还有一个nofiyAll()方法，它和notify()方法的功能类似，不同的是，它会唤醒在这个等待队列中所有等待的线程，而不是随机选择一个。Object.wait()方法并不能随便调用。它必须包含在对应的synchronize语句里，无论是wait()方法或者notify()方法都需要首先获取目标独享的一个监视器。

其中T1和T2表示两个线程。T1在正确执行wait()方法前，必须获得object对象的监视器。而wait()方法在执行后，会释放这个监视器。这样做的目的是使其他等待在object对象上的线程不至于因为T1的休眠而全部无法正常执行。

线程T2在notify()方法调用前，也必须获得object对象的监视器。所幸，此时T1已经释放了这个监视器，因此，T2可以顺利获得object对象的监视器。接着，T2执行了notify()方法尝试唤醒一个等待线程，这里假设唤醒了T1。T1在被唤醒后，要做的第一件事并不是执行后续代码，而是要尝试重新获得object对象的监视器，而这个监视器也正是T1在wait()方法执行前所持有的那个。如果暂时无法获得，则T1还必须等待这个监视器。当监视器顺利获得后，T1才可以在真正意义上继续执行。

注意：wait()方法会释放目标对象的锁，而Thread.sleep()方法不会释放锁。

blocked和waiting的线程都处于阻塞状态，不占用cpu时间片

blocked线程会在owner线程释放锁时唤醒。

waiting线程会在owner线程调用notify或者notifyall时唤醒，被唤醒后，再次进入EntryList重新竞争锁。

2、等待线程结束（join）

很多时候，一个线程的输入可能非常依赖于另外一个或者多个线程的输出，此时，这个线程就需要等待依赖的线程执行完毕，才能继续执行。jdk提供了join()操作来实现这个功能。

public final void join() throws InterruptedException;

public final synchronized void join(long millis) throws InterruptedException;

第1个方法表示无限等待，它会一直只是当前线程。直到目标线程执行完毕。

第2个方法有个参数，用于指定等待时间，如果超过了给定的时间目标线程还在执行，当前线程也会停止等待，而继续往下执行。

比如线程T1需要等待T2、T3完成之后才能继续执行，那么在T1线程中需要分别调用T2和T3的join()方法。

public static void main(String[] args) throws Exception{
    Thread thread=new Thread(){
        @Override
        public void run() {
            int sum=0;
            for (int i=0;i<=100;i++){
               sum+=i;
            }
            System.out.println("sum="+sum);
        }
    };
    thread.start();
    System.out.println("main end");
}

运行结果：

main end
sum=5050

希望主线程等待thead线程运行完成再输出main end，见下面代码：

public static void main(String[] args) throws Exception{
    Thread thread=new Thread(){
        @Override
        public void run() {
            int sum=0;
            for (int i=0;i<=100;i++){
               sum+=i;
            }
            System.out.println("sum="+sum);
        }
    };
    thread.start();
    thread.join();
    System.out.println("main end");
}

3、和谦让（yeild）

public static native void yield();

当前线程在出让CPU后，还会进行CPU资源的争夺，但是能否再抢到CPU的执行权就不一定了。因此，对Thread.yield()方法的调用好像就是在说：我已经完成了一些主要的工作，我可以休息一下了，可以让CPU给其他线程一些工作机会了。

如果觉得一个线程不太重要，或者优先级比较低，而又担心此线程会过多的占用CPU资源，那么可以在适当的时候调用一下Thread.yield()方法，给与其他线程更多的机会。

4、sleep

有两个版本的sleep方法，看得出来，核心仍旧是native方法

public static void sleep(long millis, int nanos)
throws InterruptedException {
    if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }

    if (nanos < 0 || nanos > 999999) {
        throw new IllegalArgumentException(
                            "nanosecond timeout value out of range");
    }

    if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
        millis++;
    }

    sleep(millis);
}

public static native void sleep(long millis) throws InterruptedException;

native版本的sleep

在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。该线程不丢失任何监视器的所属权。

注意：

（1）sleep不会释放锁

（2）与wait类似的是，sleep也是可中断方法

从方法签名可以看得出来，可能抛出InterruptedException，也就是说如果一个线程正在sleep，如果另外的线程将他中断（调用interrupt方法），将会抛出异常，并且中断状态将会擦除

借助于sleep方法，可以模拟线程的顺序执行

public static void main(String[] args) {

    //模拟执行任务的第一个阶段的执行
    Thread stepOne = new Thread(() -> {
        System.out.println(Thread.currentThread().getName() + " : 第一阶段任务开始执行");
        try {
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + " : 第一阶段任务执行结束");
        } catch (InterruptedException e) {
        }
    }, "firstStage");
    stepOne.start();
    //模拟任务第二个阶段的执行
    Thread stepTwo = new Thread(() -> {
        while (!Thread.State.TERMINATED.equals(stepOne.getState())) {
            try {
                Thread.sleep(100);
                System.out.println(Thread.currentThread().getName() + " : 我在等待第一阶段任务执行结束");
            } catch (InterruptedException e) {
            }
        }
        System.out.println(Thread.currentThread().getName() + " : 第二阶段任务执行结束");
    }, "secondStage");
    stepTwo.start();
}

运行结果：

firstStage : 第一阶段任务开始执行
secondStage : 我在等待第一阶段任务执行结束
secondStage : 我在等待第一阶段任务执行结束
secondStage : 我在等待第一阶段任务执行结束
secondStage : 我在等待第一阶段任务执行结束
secondStage : 我在等待第一阶段任务执行结束
secondStage : 我在等待第一阶段任务执行结束
secondStage : 我在等待第一阶段任务执行结束
secondStage : 我在等待第一阶段任务执行结束
secondStage : 我在等待第一阶段任务执行结束
firstStage : 第一阶段任务执行结束
secondStage : 我在等待第一阶段任务执行结束
secondStage : 第二阶段任务执行结束