java condition学习

学习的是这篇文章 https://blog.csdn.net/heyutao007/article/details/49889849

Condition是在java 1.5中才出现的，它用来替代传统的Object的wait()、notify()实现线程间的协作，相比使用Object的wait()、notify()，使用Condition1的await()、signal()这种方式实现线程间协作更加安全和高效。

为啥更安全和高效呢？

简单说，他的作用是使得某些线程一起等待某个条件（Condition），只有当该条件具备(signal 或者 signalAll方法被调用)时，这些等待线程才会被唤醒，从而重新争夺锁。

感觉就是说这个线程，它原来是想要获取这个锁的，但是时机未到， 先不去抢这个锁，然后时机到了，就去抢锁了。

Condition是个接口，基本的方法就是await()和signal()方法；

它的实现是哪个呢？AbstractQueuedSynchronizer里面的ConditionObject

Condition依赖于Lock接口，生成一个Condition的基本代码是lock.newCondition()
调用Condition的await()和signal()方法，都必须在lock保护之内，就是说必须在lock.lock()和lock.unlock之间才可以使用
Conditon中的await()对应Object的wait()；
Condition中的signal()对应Object的notify()；
Condition中的signalAll()对应Object的notifyAll()。

Object里面的这个wait(),这个notify(),这个notifyAll()怎么使用呢？

---

例子：

package com.study.controller;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class TestCondition {
    public static void main(String[] args) {
        final ReentrantLock reentrantLock = new ReentrantLock();
        final Condition condition = reentrantLock.newCondition();
        new Thread(new Runnable() {
            @Override
            public void run() {
                reentrantLock.lock();
                System.out.println(Thread.currentThread().getName() + "拿到锁了");
                System.out.println(Thread.currentThread().getName() + "等待信号");
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "拿到信号");
                System.out.println(Thread.currentThread().getName() + "释放锁");
                reentrantLock.unlock();
            }
        }, "线程1").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                reentrantLock.lock();
                System.out.println(Thread.currentThread().getName() + "拿到锁了");
                try {
                    System.out.println(Thread.currentThread().getName() + "拿到锁后，sleep 3000");
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "发出信号");
                condition.signalAll();
                try {
                    Thread.sleep(3000);
                    System.out.println(Thread.currentThread().getName() + "发出信后，sleep 3000");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "释放锁");
                reentrantLock.unlock();
            }
        }, "线程2").start();
    }
}

image.png

结果是线程1先拿到锁，然后await（await会释放锁)了，线程2就能获取到锁了，
线程2signalAll了后，又sleep了3s，然后释放锁，线程1在线程2释放锁之后才
拿到信号，说明signalAll（所有线程都能在锁被释放后，拿到这个锁）后，别的线程需要在这个锁完全空出来之后，才能拿到这个信号(就是拿到了这个锁),然后去获取这个锁。

假设把线程2的condition.signalAll();删除掉，线程1就拿不到锁了。

如果有三个线程，两个线程拿到锁之后await，最后一个线程拿到锁之后notify一下，释放锁，那么await的两个线程，只会有一个线程拿到锁，另外一个线程就会惨惨的等着notify。

public interface Condition {
     //使当前线程加入 await() 等待队列中，并释放当锁，当其他线程调用signal()会重新请求锁。与Object.wait()类似。
    void await() throws InterruptedException;

    //调用该方法的前提是，当前线程已经成功获得与该条件对象绑定的重入锁，否则调用该方法时会抛出IllegalMonitorStateException。
    //调用该方法后，结束等待的唯一方法是其它线程调用该条件对象的signal()或signalALL()方法。等待过程中如果当前线程被中断，该方法仍然会继续等待，同时保留该线程的中断状态。 
    void awaitUninterruptibly();

    // 调用该方法的前提是，当前线程已经成功获得与该条件对象绑定的重入锁，否则调用该方法时会抛出IllegalMonitorStateException。
    //nanosTimeout指定该方法等待信号的的最大时间（单位为纳秒）。若指定时间内收到signal()或signalALL()则返回nanosTimeout减去已经等待的时间；
    //若指定时间内有其它线程中断该线程，则抛出InterruptedException并清除当前线程的打断状态；若指定时间内未收到通知，则返回0或负数。 
    long awaitNanos(long nanosTimeout) throws InterruptedException;

    //与await()基本一致，唯一不同点在于，指定时间之内没有收到signal()或signalALL()信号或者线程中断时该方法会返回false;其它情况返回true。
    boolean await(long time, TimeUnit unit) throws InterruptedException;

   //适用条件与行为与awaitNanos(long nanosTimeout)完全一样，唯一不同点在于它不是等待指定时间，而是等待由参数指定的某一时刻。
    boolean awaitUntil(Date deadline) throws InterruptedException;
    
    //唤醒一个在 await()等待队列中的线程。与Object.notify()相似
    void signal();

   //唤醒 await()等待队列中所有的线程。与object.notifyAll()相似
    void signalAll();
}