Lock +Conditon 与synchronized对比

我们经常会将Lock与synchronized作比较，不过大多数人都是针对性能方面的对比，但其实Lock和synchronized的区别远不止性能上的区别，如果你的了解也仅限于此，那么这篇文章对你来说有很有意义，在了解Lock和Condition前强烈建议你先到上一篇了解synchronized的实现原理。

相同的设计模型

不管是Lock 还是synchronized都是基于管程模型设计的，所以它们的实现互斥、同步的思路都一样，管程是解决并发编程问题的一个通用模型，如果你理解了管程模型那么其实你对lock和synchronized已经有了一个全局的认识了，如果还不了解的话可以通过“管程模型”篇进行了解。

等待队列数量的不同

synchronized 只有一个队列，不管是因为竞争不到锁，还是因为某个条件没达到而阻塞，它们阻塞后都是放到一个等待队列里。

但是lock与Condition结合，可以创建多个条件队列，因为不同的条件不满足而阻塞的线程都可以放到不同的队列里， 这样就可以做到按需排队，按需通知。

我们以去医院看病排队的场景来理解synchronized与Lock在队列上的不同有什么影响:

去医院看病的时候通常要经过挂号、检查、就医这么几个流程,每个流程都有一个对应的负责人。 如果是使用synchronized，那么我们挂号、检查、就医的人员是全部排在一个队伍里面的，这样的话就会造成一个情况， 就是当我们就医的负责人叫到队伍下一个时，这个人很有可能还没有挂完号或者没做完检查，所以导致经常叫到队伍里的人都不满足条件而做很多的无用功。

如果是使用lock+condition的话，那么在这里就可以通过创建多个condition来表示不同的排队，挂号、检查、就医分别为不同 的队列，当某个挂号或者检查、就医的负责人空闲下来后，就唤醒对应队列的等待线程。

Lock+Condition的使用

用Condition实现消息队列

前面我们也知道了Lock+Condition能实现多队列，那么多个队列到底在什么样的使用场景呢，下面我们以一个消息队列的例子来了解Lock+Condition的使用。

场景：实现一个消息队列，有多个线程会往该队列里面写消息，同时也会存在多个线程会从消息里面读消息，队列的容量只有10个。

条件：

队列不为满条件：队列里面消息没有满的情况下才能往队里面添加消息。

队列不为空条件：消费消息的时候队列里必须有消息才进行消费。

加锁：因为是多线程所以需要防止消息被多个线程同时消费，同时也要防止写消息的时候一个线程存的消息被其他线程覆盖，所以队列操作的时候必须加锁。

实现思路：

1、防止多个线程写消息覆盖、多个线程读取到同一个消息，那么我们可以用一把锁来控制消息的读写，保证线程操作的互斥。

2、定义两个条件，一个条件“队列消息不为满”，一个条件"队列消息不为空"。

3、队列消息不为满的Condition队列是用来阻塞写入的线程的，当队列容量=10的时候，说明队列已经满了不能再写了，这个时候写入线程就阻塞到消息不满的Condition队列等待，意思是当队列容量<10时，就可以唤醒此队列的线程进行消息的写入。

4、队列消息不为空的Condition队列是读取消息的线程排队队列，当队列容量=0的时候，说明队列已经空了没有消息读取了，这个时候读取消息的线程就阻塞进入 消息不空的Condition等待队列，意思是当队列容量>1时，就可以可以唤醒此队列的线程进行消息的读取。

当队列已满的时候就不再进行消息的写入，写入消息的线程进入队列是否已满的队列等待，然后唤醒

队列代码：

 public class MyQueue {​private    Lock lock=new ReentrantLock();//锁private   List listQueue=new ArrayList();//存储消息的集合private    Condition notNull=lock.newCondition();//队列不为空private   Condition notFull=lock.newCondition();//队列不为满​​public    void add(String message){lock.lock();//操作队列先加锁try {//队列满了，通知消费者线程，生产线程阻塞while (listQueue.size()>=10){notNull.signal();System.out.println("队列已满"+ Thread.currentThread().getName()+"等待");notFull.await();}​//往队列添加一条消息，同时通知消费者有新消息了listQueue.add(message);System.out.println(Thread.currentThread().getName()+"生产一条消息");notNull.signal();//通知消费者线程} catch (InterruptedException e) {e.printStackTrace();}finally {lock.unlock();//释放锁}}​​public void remove(){lock.lock();//操作队列先加锁try {//队列空了，通知生产线程，消费线程阻塞while (listQueue.size()==0){System.out.println("队列已空"+ Thread.currentThread().getName()+"等待");notNull.await();}//队列删除一条消息，同时通知生产者队列有位置了listQueue.get(0);listQueue.remove(0);System.out.println(Thread.currentThread().getName()+"消费一条消息");notFull.signal();//同时通知生产者队列​} catch (InterruptedException e) {e.printStackTrace();}finally {lock.unlock();}}​}

测试：

 public class TestMyQueue {​private static MyQueue myQueue=new MyQueue();​public static void main(String[] args) throws Exception {for(int i=1;i<=10;i++){Thread provider=new Thread(new Runnable() {public void run() {while (true){myQueue.add("消息");}}},"生产线程"+i);​Thread consumer=new Thread(new Runnable() {public void run() {while (true){myQueue.remove();}}},"消费线程"+i);provider.start();consumer.start();}​}​}

测试结果：

根据上面Lock+Condition实现队列的案例，我们大概已经可以在脑海中推导出来一个Lock+Condition的类似下图的流程了

Lock+Condition原理分析

下面我们根据一个简单的模拟场景进行Lock+Condition的原理分析

对线程A，线程B，按先后顺序线程A调用Lock.lock()、condition.await()，线程B调用 Lock.lock()、condition.signal()，分析其整个执行过程。

   Lock lock=new ReentrantLock(); //锁Condition condition=lock.newCondition();//条件队列

第一步：创建AQS同步队列

因为ReentrantLock 内部维护的是一个AQS同步队列，在掉员工new ReentrantLock()的时候就会初始化了一个AQS队列，队列信息如下图：

第二步：线程A调用lock.lock();

因为线程A是第一个加锁的线程所以，所以加锁成功后AQS队列里面信息如下

第三步：线程A调用condition.await()方法;

condition.await()方法的主要逻辑：

1、首先调用addConditionWaiter();创建一个节点，把当前节点加入到Condition的队列(此队列为单向链表)

2、然后调用fullyRelease(node);释放AQS锁，并唤醒AQS同步队列等待节点中的一个线程。

3、最后LockSupport.park(this);挂起当前线程。

那么此时会产生两个队列，一个是AQS队列，一个是Condition队列，最后信息如下图：

源码如下：

  public final void await() throws InterruptedException {if (Thread.interrupted())throw new InterruptedException();//创建一个节点，添加到Condition队列(单向链表)Node node = addConditionWaiter();//释放锁，并唤醒AQS同步等待队列((双向链表))中的一个节点线程int savedState = fullyRelease(node);​int interruptMode = 0;//判断当前节点是否存在于AQS队列while (!isOnSyncQueue(node)) {//如果不存在于AQS阻塞队列，则说明在Condition队列里，则将该线程挂起阻塞LockSupport.park(this);​//当前节点线程被唤醒后继续从这里执行if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)break;}//竞争锁if (acquireQueued(node, savedState) && interruptMode != THROW_IE)interruptMode = REINTERRUPT;//清除Condition队列无效节点if (node.nextWaiter != null)unlinkCancelledWaiters();if (interruptMode != 0)reportInterruptAfterWait(interruptMode);}

第四步：线程B调用lock.lock()进行加锁：

此时线程B进行加锁，发现AQS是没有加锁的状态所以加锁成功。

第五步：线程B调用condition.signal()唤醒 condition队列里的一个阻塞线程：

主要逻辑：

1、首先验证当前线程是否获取了锁，没有获取锁直接抛异常，没有获得锁的线程是不允许调用condition.signal()方法的；

2、获得condition队列的firstWaiter首部节点,把此节点从condition队列移出，添加到AQS队列中。

3、唤醒AQS中一个等待节点的线程。

最后执行结果如下图：

condition.signal() 源码：

  public final void signal() {//验证当前线程是否获得了锁if (!isHeldExclusively())throw new IllegalMonitorStateException();//获取第一个Condition等待节点Node first = firstWaiter;if (first != null)doSignal(first);}

  private void doSignal(Node first) {do {//如果链表只有一个节点if ( (firstWaiter = first.nextWaiter) == null)lastWaiter = null;first.nextWaiter = null;} while (!transferForSignal(first) &&(first = firstWaiter) != null);}

 final boolean transferForSignal(Node node) {//把当前节点状态waitStatus从等待condition.变更为新建状态if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))return false;​​//上一步成功则把当前节点添加到AQS同步队列尾部，返回链表中的原尾部节点Node p = enq(node);int ws = p.waitStatus;//唤醒原尾部节点的等待线程if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))LockSupport.unpark(node.thread);return true;}

参考文章：并发工具（锁）：深入Lock+Condition