显式锁（二）

作者: 少博先生 | 来源:发表于2017-10-06 11:56 被阅读0次

显式锁（二）
从 synchronized 到 CAS 和 AQS - 彻底弄
13. 显式锁：Lock接口
05.锁机制和条件对象简述
线程安全，内存可见性，竞态条件，内置锁，显式锁概述
Android面试知识点（三）*
显式锁
显式锁
显式锁
3.ReentrantLock核心原理分析

之前在介绍线程的状态及转换中，提到了Object有wait()、wait(long timeout)、notify()、notifyAll()方法，这些方法与synchronized配合使用，可以实现等待/通知模式。无独有偶，Conditon接口也提供了类似Object的监视器方法，与Lock配合也能实现通知/等待模式。

1、Condition接口

①接口介绍

在上篇显式锁(一)介绍Lock接口时，Lock有一个方法叫" Condition newCondition(); "，此方法是获取等待通知组件，也就是Conditon，获取的Condition与此Lock绑定。也可以说，Conditon是依赖Lock对象。

java-8
public interface Condition {
    //当前线程进入等待状态直到被通知或中断
    void await() throws InterruptedException;
    //当前线程进入等待状态直到被通知，对中断不敏感
    void awaitUninterruptibly();
    //当前线程进入等待状态直到被通知、中断或超时
    long awaitNanos(long nanosTimeout) throws InterruptedException;
    //当前线程进入等待状态直到被通知、中断，在指定时间内被通知返回true,否则false
    boolean await(long time, TimeUnit unit) throws InterruptedException;
    boolean awaitUntil(Date deadline) throws InterruptedException;
    //唤醒一个等待在Condition上的线程
    void signal();
    //唤醒所有等待在Conditon上的线程
    void signalAll();
}

一般的使用套路如下:

Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();

public void conditionWait() throws InterruptedException{
      lock.lock();
      try{
           condition.await();
      }finally{
           lock.unlock();
      }
}

public void conditionSingal() throws InterruptedException{
       lock.lock();
       try{
            condition.singal();
       }finally{
            lock.unlock();
       }  
}

②使用示例

通过一个生产者/消费者的例子来使用下Condition:

/**
 * Created by bxw on 2017/10/5.
 */
public class Depot {
    private int capacity;
    private int size;
    private Lock lock;
    private Condition consumerCond;
    private Condition produceCond;

    public Depot(int capacity) {
        this.capacity = capacity;
        this.size = 0;
        this.lock = new ReentrantLock();
        this.consumerCond = lock.newCondition();
        this.produceCond = lock.newCondition();
    }

    public void produce(int val){
        lock.lock();
        try {
            int left = val;
            while(left > 0){
                while(size >= capacity){
                    produceCond.await();
                }
                int produce = (left + size) > capacity ? (capacity - size) : left;
                size += produce;
                left -= produce;
                System.out.println(Thread.currentThread().getName() + ", ProcudeVal=" + val +", produce=" + produce + ",size=" + size);
                consumerCond.signalAll();
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void consumer(int val){
        lock.lock();
        try {
            int left = val;
            while (left > 0) {
                while (size <= 0) {
                    consumerCond.await();
                }
                int consumer = (size <= left) ? size : left;
                size -= consumer;
                left -= consumer;
                System.out.println(Thread.currentThread().getName() + ", ConsumerVal=" + val + ", consumer=" + consumer + ", size=" + size);
                produceCond.signalAll();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

public class Producer {
    private Depot depot;
    public Producer(Depot depot) {
        this.depot = depot;
    }

    public void produceThing(final int amount) {
        new Thread(new Runnable() {
            public void run() {
                depot.produce(amount);
            }
        }).start();
    }
}

public class Consumer {
    private Depot depot;
    public Consumer(Depot depot) {
        this.depot = depot;
    }

    public void consumerThing(final int amount) {
        new Thread(new Runnable() {
            public void run() {
                depot.consumer(amount);
            }
        }).start();
    }
}

public class Test {
    public static void main(String[] args) {
        // 仓库
        Depot depot = new Depot(100);
        // 消费者
        Consumer consumer = new Consumer(depot);
        // 生产者
        Producer produce = new Producer(depot);
        produce.produceThing(5);
        consumer.consumerThing(5);
        produce.produceThing(2);
        consumer.consumerThing(5);
        produce.produceThing(5);
    }
}

运行结果：

从结果看出，Thread-0和Thread-1比较和谐，Thread-0生产了5个，Thread-1消费了5个，剩余0。接着Thread-2又生产了2个，Thread-3需要消费5个，但仓库中只有2个，所以先将库存的2个产品全部消费，然后这个线程进入等待队列，等待生产，随后生产出了5个产品，生产者生产后又执行signalAll方法将等待队列中所有的线程都唤醒，Thread-3继续消费还需要的3个产品，仓库还剩余了2个。

③实现分析

首先从Lock.newCondition分析，以ReentrantLock为例，会返回一个ConditionObject对象。

返回ConditionObject对象

那ConditionObject为何物，原来它是AbstractQueuedSynchronizer（简称AQS）的一个内部类，拥有两个节点：头节点、尾节点。

ConditionObject

因为每个ConditionObject都包含一个等待队列，这是Conditon实现等待/通知的关键。等待队列是个FIFO队列，队列中每个节点都包含了一个线程的引用，该线程是在Condition对象上等待的线程，如果一个线程调用了Condition.await()方法，该线程就释放锁、构造节点加入等待队列并进入等待状态。节点（Node）的定义也是AQS中的一个内部类。