标签：tps 中断 queue lock == tun get als 基本结构
在使用Lock之前，我们使用的最多的同步方式应该是synchronized关键字来实现同步方式了。配合Object的wait()、notify()系列方法可以实现等待/通知模式。Condition接口也提供了类似Object的监视器方法，与Lock配合可以实现等待/通知模式，但是这两者在使用方式以及功能特性上还是有差别的。Object和Condition接口的一些对比。摘自《Java并发编程的艺术》
一、Condition接口介绍和示例
首先我们需要明白condition对象是依赖于lock对象的，意思就是说condition对象需要通过lock对象进行创建出来(调用Lock对象的newCondition()方法)。consition的使用方式非常的简单。但是需要注意在调用方法前获取锁。
1 package com.ydl.test.juc; 2 3 import java.util.concurrent.ExecutorService; 4 import java.util.concurrent.Executors; 5 import java.util.concurrent.locks.Condition; 6 import java.util.concurrent.locks.Lock; 7 import java.util.concurrent.locks.ReentrantLock; 8 9 public class ConditionUseCase { 10 11 public Lock lock = new ReentrantLock(); 12 public Condition condition = lock.newCondition(); 13 14 public static void main(String[] args) { 15 ConditionUseCase useCase = new ConditionUseCase(); 16 ExecutorService executorService = Executors.newFixedThreadPool (2); 17 executorService.execute(new Runnable() { 18 @Override 19 public void run() { 20 useCase.conditionWait(); 21 } 22 }); 23 executorService.execute(new Runnable() { 24 @Override 25 public void run() { 26 useCase.conditionSignal(); 27 } 28 }); 29 } 30 31 public void conditionWait() { 32 lock.lock(); 33 try { 34 System.out.println(Thread.currentThread().getName() + "拿到锁了"); 35 System.out.println(Thread.currentThread().getName() + "等待信号"); 36 condition.await(); 37 System.out.println(Thread.currentThread().getName() + "拿到信号"); 38 }catch (Exception e){ 39 40 }finally { 41 lock.unlock(); 42 } 43 } 44 public void conditionSignal() { 45 lock.lock(); 46 try { 47 Thread.sleep(5000); 48 System.out.println(Thread.currentThread().getName() + "拿到锁了"); 49 condition.signal(); 50 System.out.println(Thread.currentThread().getName() + "发出信号"); 51 }catch (Exception e){ 52 53 }finally { 54 lock.unlock(); 55 } 56 } 57 58 } 59 60
1 pool-1-thread-1拿到锁了 2 pool-1-thread-1等待信号 3 pool-1-thread-2拿到锁了 4 pool-1-thread-2发出信号 5 pool-1-thread-1拿到信号
如示例所示，一般都会将Condition对象作为成员变量。当调用await()方法后，当前线程会释放锁并在此等待，而其他线程调用Condition对象的signal()方法，通知当前线程后，当前线程才从await()方法返回，并且在返回前已经获取了锁。
二、Condition接口常用方法
condition可以通俗的理解为条件队列。当一个线程在调用了await方法以后，直到线程等待的某个条件为真的时候才会被唤醒。这种方式为线程提供了更加简单的等待/通知模式。Condition必须要配合锁一起使用，因为对共享状态变量的访问发生在多线程环境下。一个Condition的实例必须与一个Lock绑定，因此Condition一般都是作为Lock的内部实现。
await() ：造成当前线程在接到信号或被中断之前一直处于等待状态。
await(long time, TimeUnit unit) ：造成当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。
awaitNanos(long nanosTimeout) ：造成当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。返回值表示剩余时间，如果在nanosTimesout之前唤醒，那么返回值 = nanosTimeout - 消耗时间，如果返回值 <= 0 ,则可以认定它已经超时了。
awaitUninterruptibly() ：造成当前线程在接到信号之前一直处于等待状态。【注意：该方法对中断不敏感】。
awaitUntil(Date deadline) ：造成当前线程在接到信号、被中断或到达指定最后期限之前一直处于等待状态。如果没有到指定时间就被通知，则返回true，否则表示到了指定时间，返回返回false。
signal() ：唤醒一个等待线程。该线程从等待方法返回前必须获得与Condition相关的锁。
signal()All ：唤醒所有等待线程。能够从等待方法返回的线程必须获得与Condition相关的锁。
三、Condition接口原理简单解析
Condition是AQS的内部类。每个Condition对象都包含一个队列(等待队列)。等待队列是一个FIFO的队列，在队列中的每个节点都包含了一个线程引用，该线程就是在Condition对象上等待的线程，如果一个线程调用了Condition.await()方法，那么该线程将会释放锁、构造成节点加入等待队列并进入等待状态。等待队列的基本结构如下所示。
等待分为首节点和尾节点。当一个线程调用Condition.await()方法，将会以当前线程构造节点，并将节点从尾部加入等待队列。新增节点就是将尾部节点指向新增的节点。节点引用更新本来就是在获取锁以后的操作，所以不需要CAS保证。同时也是线程安全的操作。
3.2、等待
当线程调用了await方法以后。线程就作为队列中的一个节点被加入到等待队列中去了。同时会释放锁的拥有。当从await方法返回的时候。一定会获取condition相关联的锁。当等待队列中的节点被唤醒的时候，则唤醒节点的线程开始尝试获取同步状态。如果不是通过 其他线程调用Condition.signal()方法唤醒，而是对等待线程进行中断，则会抛出InterruptedException异常信息。
3.3、通知
调用Condition的signal()方法，将会唤醒在等待队列中等待最长时间的节点（条件队列里的首节点），在唤醒节点前，会将节点移到同步队列中。当前线程加入到等待队列中如图所示：
在调用signal()方法之前必须先判断是否获取到了锁。接着获取等待队列的首节点，将其移动到同步队列并且利用LockSupport唤醒节点中的线程。节点从等待队列移动到同步队列如下图所示：
被唤醒的线程将从await方法中的while循环中退出。随后加入到同步状态的竞争当中去。成功获取到竞争的线程则会返回到await方法之前的状态。
四、总结
调用await方法后，将当前线程加入Condition等待队列中。当前线程释放锁。否则别的线程就无法拿到锁而发生死锁。自旋(while)挂起，不断检测节点是否在同步队列中了，如果是则尝试获取锁，否则挂起。当线程被signal方法唤醒，被唤醒的线程将从await()方法中的while循环中退出来，然后调用acquireQueued()方法竞争同步状态。
五、利用Condition实现生产者消费者模式
1 2 import java.util.LinkedList; 3 import java.util.concurrent.locks.Condition; 4 import java.util.concurrent.locks.Lock; 5 import java.util.concurrent.locks.ReentrantLock; 6 7 public class BoundedQueue { 8 9 private LinkedList<Object> buffer; //生产者容器 10 private int maxSize ; //容器最大值是多少 11 private Lock lock; 12 private Condition fullCondition; 13 private Condition notFullCondition; 14 BoundedQueue(int maxSize){ 15 this.maxSize = maxSize; 16 buffer = new LinkedList<Object>(); 17 lock = new ReentrantLock(); 18 fullCondition = lock.newCondition(); 19 notFullCondition = lock.newCondition(); 20 } 21 22 /** 23 * 生产者 24 * @param obj 25 * @throws InterruptedException 26 */ 27 public void put(Object obj) throws InterruptedException { 28 lock.lock(); //获取锁 29 try { 30 while (maxSize == buffer.size()){ 31 notFullCondition.await(); //满了，添加的线程进入等待状态 32 } 33 buffer.add(obj); 34 fullCondition.signal(); //通知 35 } finally { 36 lock.unlock(); 37 } 38 } 39 40 /** 41 * 消费者 42 * @return 43 * @throws InterruptedException 44 */ 45 public Object get() throws InterruptedException { 46 Object obj; 47 lock.lock(); 48 try { 49 while (buffer.size() == 0){ //队列中没有数据了 线程进入等待状态 50 fullCondition.await(); 51 } 52 obj = buffer.poll(); 53 notFullCondition.signal(); //通知 54 } finally { 55 lock.unlock(); 56 } 57 return obj; 58 } 59 60 } 61
参考：
Java并发编程的艺术
Java并发编程网
标签：tps 中断 queue lock == tun get als 基本结构
原文地址：https://www.cnblogs.com/gemine/p/9039012.html
