ReentrantLock&Condition 使用

一、ReentrantLock是什么

ReentrantLock是一个互斥的可重入锁。互斥的意思就是排他，独占，只能一个线程获取到锁。可重入的意思就是单个线程可以多次重复获取锁。

二、ReentrantLock常用方法

方法名	说明	抛出异常
lock（）	一直阻塞获取锁，直到获取成功	无
lockInterruptibly（）	尝试获取锁，直到获取锁或者线程被中断	InterruptedException
tryLock（）	尝试获取空闲的锁，获取成功返回true，获取失败返回false,不会阻塞，立即返回	无
tryLock(long time, TimeUnit unit)	尝试在time时间内获取空闲的锁，在等待时间内可以被中断	InterruptedException
unlock（）	释放锁	无
newCondition()	返回当前锁的一个condition实例，用于条件性等待	无

三、ReentrantLock与synchronized

ReentrantLock与 synchronized功能其实差不多，都是可重入锁。synchronized自动释放锁，需要通过unlock()手动释放锁。ReentrantLock但ReentrantLock功能更强大一点，可以响应中断，另外配合condition可以等待/唤醒特定的线程。

四、Condition

Condition用来使线程等待或者唤醒线程，唤醒的线程是使用同一个condition等待的线程，所以可以唤醒特定的线程。

四、代码示例

/**
 * 
仓库类
 */
public class Depot {
    private int capacity;    // 仓库的容量
    private int size;        // 仓库的实际数量
    private Lock lock;        // 独占锁
    private Condition fullCondtion;            // 生产条件
    private Condition emptyCondtion;        // 消费条件

    /**
     * 初始化
     */
    public Depot() {
        capacity = 100;
        size = 0;
        lock = new ReentrantLock();
        fullCondtion = lock.newCondition();
        emptyCondtion = lock.newCondition();
    }

    /**
     * 
生产流程
     *
     * @param val:生产的个数
     */
    public void produce(int val) {
        try {
            lock.lock();
            System.out.println("生产者:" + Thread.currentThread().getName() + "开始执行");
            //left:还需生产的个数
            int left = val;
            while (left > 0) {
                //当仓库满了，需要暂停生产
                if (size >= capacity) {
                    System.out.println(Thread.currentThread().getName() + ":当前仓库已满，生产进程进入等待");
                    //当前生产进程阻塞
                    fullCondtion.await();
                }
                // incr：此次生产的数量
                int incr = (capacity - size) > left ? left : (capacity - size);
                size = size + incr;
                left = left - incr;
                System.out.println(Thread.currentThread().getName() + "生产:incr=" + incr + ",left=" + left + ",size=" + size);
                // 生产完了，唤起消费进程
                emptyCondtion.signal();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //释放锁
            lock.unlock();
        }
    }

    /**
     * 
消费流程
     *
     * @param val:消费的个数
     */
    public void consume(int val) {
        try {
            lock.lock();
            System.out.println("消费者:" + Thread.currentThread().getName() + "开始执行");
            //left:剩余消费的数量
            int left = val;
            while (left > 0) {
                if (size <= 0) {
                    System.out.println(Thread.currentThread().getName() + ":当前仓库已空，消费进程进入等待");
                    emptyCondtion.await();
                }
                // dec : 此次消费的个数
                int dec = size > left ? left : size;
                left = left - dec;
                size = size - dec;
                System.out.println(Thread.currentThread().getName() + "消费:dec=" + dec + ",left=" + left + ",size=" + size);
                // 唤醒生产进程
                fullCondtion.signal();
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
}

生产者：

/**
 * 
生产者
 */
public class Producer {
    private Depot depot;

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

    public void produce(int val){
        new Thread(){
            @Override
            public void run() {
                depot.produce(val);
            }
        }.start();
    }
}

消费者：

/**
 * 
消费者
 */
public class Consumer {
    private Depot depot;

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

    public void consume(int val){
        new Thread(){
            @Override
            public void run() {
               depot.consume(val);
            }
        }.start();
    }
}

函数调用：

    public static void main(String[] args) {
        SpringApplication.run(RoadApplication.class, args);

        Depot depot = new Depot();
        Producer producer = new Producer(depot);
        Consumer consumer = new Consumer(depot);

        consumer.consume(150);
        producer.produce(200);
        producer.produce(100);
        consumer.consume(150);
        consumer.consume(50);
        producer.produce(200);
    }

运行结果：

消费者:Thread-7开始执行
Thread-7:当前仓库已空，消费进程进入等待
生产者:Thread-8开始执行
Thread-8生产:incr=100,left=100,size=100
Thread-8:当前仓库已满，生产进程进入等待
生产者:Thread-9开始执行
Thread-9:当前仓库已满，生产进程进入等待
生产者:Thread-12开始执行
Thread-12:当前仓库已满，生产进程进入等待
Thread-7消费:dec=100,left=50,size=0
Thread-7:当前仓库已空，消费进程进入等待
消费者:Thread-10开始执行
Thread-10:当前仓库已空，消费进程进入等待
消费者:Thread-11开始执行
Thread-11:当前仓库已空，消费进程进入等待
Thread-8生产:incr=100,left=0,size=100
Thread-7消费:dec=50,left=0,size=50
Thread-9生产:incr=50,left=50,size=100
Thread-9:当前仓库已满，生产进程进入等待
Thread-10消费:dec=100,left=50,size=0
Thread-10:当前仓库已空，消费进程进入等待
Thread-12生产:incr=100,left=100,size=100
Thread-12:当前仓库已满，生产进程进入等待
Thread-11消费:dec=50,left=0,size=50
Thread-9生产:incr=50,left=0,size=100
Thread-10消费:dec=50,left=0,size=50
Thread-12生产:incr=50,left=50,size=100
Thread-12:当前仓库已满，生产进程进入等待