【java并发】java Condition学习

参考：Java并发之Condition

简介

Condition是基于Lock类存在的，也是用于线程的通信，但是是更加细粒度的
Condition的优势是支持多路等待，就是我可以定义多个Condition，每个condition控制线程的一条执行通路。传统方式只能是一路等待。
之后可以使用condition的await()和signal()方法进行线程的通信

使用案例

package lockTest.condition;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * @Author: WalkerShen
 * @DATE: 2022/3/22
 * @Description: 使用condition的await和signal
 **/
public class ConditionTest {
    private static Lock lock=new ReentrantLock();
    private static Condition condition=lock.newCondition();

    public static void main(String[] args) {
        //1、先让线程先执行，调用await方法,获得锁之后再阻塞
        new Thread(()->{
            await();
        },"线程A").start();


        //2、线程B 休眠2s目的是为了让线程A执行await方法阻塞，然后再调用signalAll方法唤醒
        new Thread(()->{
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            signalAll();
        },"线程B").start();

    }


    /**
     * @Author: WalkerShen
     * @DATE: 2022/3/22
     * @Description: 构建await方法
     **/
    private static void await(){
        try {
            String name = Thread.currentThread().getName();
            lock.lock();
            System.out.println(name+"拿到锁");
            System.out.println(name+"等待信号");
            condition.await();
            System.out.println(name+"重新拿到信号");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    /**
     * 通知方法
     */
    private static void signalAll(){
        try {
            String name = Thread.currentThread().getName();
            lock.lock();
            System.out.println(name+"拿到锁");
            condition.signalAll();
            System.out.println(name+"使用signalAll发出信号");
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

}

执行结果：

Thread-0拿到锁
Thread-0等待信号
Thread-1拿到锁
Thread-1使用signalAll发出信号
Thread-0重新拿到信号

常用方法

condition可以通俗的理解为条件队列。
当一个线程在调用了await方法以后，直到线程等待的某个条件为真的时候才会被唤醒。这种方式为线程提供了更加简单的等待/通知模式。
Condition必须要配合锁一起使用，因为对共享状态变量的访问发生在多线程环境下。一个Condition的实例必须与一个Lock绑定，因此Condition一般都是作为Lock的内部实现。

1. await() ：造成当前线程在接到信号或被中断之前一直处于等待状态。
2. await(long time, TimeUnit unit) ：造成当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。
3. awaitNanos(long nanosTimeout) ：造成当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。返回值表示剩余时间，如果在nanosTimesout之前唤醒，那么返回值 = nanosTimeout - 消耗时间，如果返回值 <= 0 ,则可以认定它已经超时了。
4. awaitUninterruptibly() ：造成当前线程在接到信号之前一直处于等待状态。【注意：该方法对中断不敏感】。
5. awaitUntil(Date deadline) ：造成当前线程在接到信号、被中断或到达指定最后期限之前一直处于等待状态。如果没有到指定时间就被通知，则返回true，否则表示到了指定时间，返回返回false。
6. signal() ：唤醒一个等待线程。该线程从等待方法返回前必须获得与Condition相关的锁。
7. signal()All ：唤醒所有等待线程。能够从等待方法返回的线程必须获得与Condition相关的锁。

原理简单解析

Condition是AQS的内部类。
每个Condition对象都包含一个队列(等待队列)。

等待队列是一个FIFO的队列，在队列中的每个节点都包含了一个线程引用，该线程就是在Condition对象上等待的线程，如果一个线程调用了Condition.await()方法，那么该线程将会释放锁、构造成节点加入等待队列并进入等待状态。等待队列的基本结构如下所示。

等待分为首节点和尾节点。
当一个线程调用Condition.await()方法，将会以当前线程构造节点，并将节点从尾部加入等待队列。
新增节点就是将尾部节点指向新增的节点。
节点引用更新本来就是在获取锁以后的操作，所以不需要CAS保证。同时也是线程安全的操作。

等待

当线程调用了await方法以后。
线程就作为队列中的一个节点被加入到等待队列中去了。
同时会释放锁的拥有。当从await方法返回的时候。一定会获取condition相关联的锁。当等待队列中的节点被唤醒的时候，则唤醒节点的线程开始尝试获取同步状态。如果不是通过 其他线程调用Condition.signal()方法唤醒，而是对等待线程进行中断，则会抛出InterruptedException异常信息。

通知

调用Condition的signal()方法，将会唤醒在等待队列中等待最长时间的节点（条件队列里的首节点），在唤醒节点前，会将节点移到同步队列中。当前线程加入到等待队列中如图所示：

在调用signal()方法之前必须先判断是否获取到了锁。接着获取等待队列的首节点，将其移动到同步队列并且利用LockSupport唤醒节点中的线程。节点从等待队列移动到同步队列如下图所示：

被唤醒的线程将从await方法中的while循环中退出。随后加入到同步状态的竞争当中去。成功获取到竞争的线程则会返回到await方法之前的状态。

总结

调用await方法后，将当前线程加入Condition等待队列中。
当前线程释放锁。否则别的线程就无法拿到锁而发生死锁。自旋(while)挂起，不断检测节点是否在同步队列中了，如果是则尝试获取锁，否则挂起。当线程被signal方法唤醒，被唤醒的线程将从await()方法中的while循环中退出来，然后调用acquireQueued()方法竞争同步状态。

利用Condition实现生产者消费者模式

生产者

package productConsumerMode.lockAndSignal;

import java.util.List;
import java.util.Random;

public class Producer implements Runnable {
    private List<String> bumList;

    public Producer(List<String> bumList) {
        this.bumList = bumList;
    }

    @Override
    public void run() {

        while (true) {
            try {
                //加锁,记住：condition是需要和lock进行搭配的
                Test.LOCK.lock();
                //若中断则退出循环
                if (Thread.currentThread().isInterrupted()) break;

                //当队列的长度大于等于最大长度的时候，则停止生产，否则则继续生产
                if (bumList.size() >= Test.LENGTH) {
                    System.out.println(Thread.currentThread().getName() + "停止生产包子");
                    //empty通知  full停止
                    Test.EMPTY.signalAll();
                    Test.FULL.await();
                }else{
                    Random random = new Random();
                    int i = random.nextInt(100);
                    bumList.add("包子" + i);
                    System.out.println("【生产者】"+Thread.currentThread().getName()+"生产包子"+i);
                }
                Thread.sleep(1000);

                //解锁
                Test.LOCK.unlock();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}

消费者

package productConsumerMode.lockAndSignal;

import java.util.List;
/**
 * @Author: WalkerShen
 * @DATE: 2022/3/22
 * @Description: 消费者
 **/
public class Consumer implements Runnable{
    private List<String> bumList;

    public Consumer(List<String> bumList) {
        this.bumList = bumList;
    }


    @Override
    public void run() {
        try {
            //循环
            while(true){
                //线程中断则退出循环
                if(Thread.currentThread().isInterrupted()) break;
                //加锁
                Test.LOCK.lock();
                //队列为空则通知full，empty暂停
                //否则则消费包子
                if(bumList.size()==0){
                    System.out.println("包子已经被消费完了");
                    Test.FULL.signalAll();
                    Test.EMPTY.await();
                }else{
                    String remove = bumList.remove(0);
                    System.out.println("【消费者】"+Thread.currentThread().getName()+"消费"+remove);
                }

                Thread.sleep(1000);
                //解锁
                Test.LOCK.unlock();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

测试

package productConsumerMode.lockAndSignal;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Test {
    //队列长度
    public final static Integer LENGTH=5;

    //新建一个ReentrantLock
    public static ReentrantLock LOCK=new ReentrantLock();
    //之后创建两个condition，分别是队列满，队列空
    public static Condition EMPTY=LOCK.newCondition();
    public static Condition FULL=LOCK.newCondition();

    //包子队列
    static volatile List<String> bumList;


    public static void main(String[] args) {
        bumList=new ArrayList<>();
        Producer producer = new Producer(bumList);
        Consumer consumer = new Consumer(bumList);
        Producer producer1 = new Producer(bumList);
        Consumer consumer1 = new Consumer(bumList);

        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(producer);
        executorService.execute(consumer);
        executorService.execute(producer1);
        executorService.execute(consumer1);
        executorService.shutdown();

    }
}