三.多线程JUC篇-3.10 ReentrantLock-蒲公英云

三.多线程JUC篇-3.10 ReentrantLock

一.概念

ReentrantLock重入锁，是实现Lock接口的一个类，也是在实际编程中使用频率很高的一个锁
支持重入性，表示能够对共享资源能够重复加锁，即当前线程获取该锁再次获取不会被阻塞
(1) 在线程获取锁的时候，如果已经获取锁的线程是当前线程的话则直接再次获取成功
(2) 由于锁会被获取n次，那么只有锁在被释放同样的n次之后，该锁才算是完全释放成功
ReentrantLock还支持公平锁和非公平锁两种方式

二.与synchronized比较

ReentrantLock可以添加多个检控条件(condition)，但是synchronized只可以添加一个
ReentrantLock可以控制得到锁的顺序（公平锁），也可以和synchronized一样使用非公平锁
ReentrantLock支持获取锁超时（tryLock()方法）以及获取锁响应中断的操作（lockInterruptibly()方法，synchronized不支持
-在高争用条件下，ReentarntLock的可伸缩性优于synchronized

三.何时应该使用ReentrantLock？

在确实需要一些 synchronized 所没有的特性的时候，比如时间锁等候、可中断锁等候、无块结构锁、多个条件变量或者锁投票
ReentrantLock 还具有可伸缩性的好处，应当在高度争用的情况下使用它。但是请记住，大多数 synchronized 块几乎从来没有出现过争用，所以可以把高度争用放在一边
我建议用 synchronized 开发，直到确实证明 synchronized 不合适，而不要仅仅是假设如果使用 ReentrantLock “性能会更好”
请记住，这些是供高级用户使用的高级工具。（而且，真正的高级用户喜欢选择能够找到的最简单工具，直到他们认为简单的工具不适用为止。）一如既往，首先要把事情做好，然后再考虑是不是有必要做得更快

四.例子

(1) 生产者代码：
public class Producer implements Runnable { 
    /** * 产品容器 */
    private List<Integer> container;
    private Lock lock;
    /** * 生产者条件 */
    private Condition producerCondition;
    /** * 消费者条件 */
    private Condition consumerCondition;
    public Producer(List<Integer> container, Lock lock, Condition producerCondition, Condition consumerCondition) { 
        this.container = container;
        this.lock = lock;
        this.producerCondition = producerCondition;
        this.consumerCondition = consumerCondition;
    }
    public void produce() { 
        //产品容器容量大小
        int capacity = 5;
        try { 
            //获得锁
            lock.lock();
            //容器满了，不在生产
            if (container.size() == capacity) { 
                System.out.println("生产满了。。。。");
                producerCondition.await();
            }
            Random random = new Random();
            int p = random.nextInt(50);
            //模拟1秒生产一个产品
            TimeUnit.MILLISECONDS.sleep(1000);
            System.out.println("生产产品：" + p);
            container.add(p);
            //生产一个产品，通知消费者
            consumerCondition.signal();
        } catch (InterruptedException e) { 
            e.printStackTrace();
        } finally { 
            //释放锁
            lock.unlock();
        }
    }
    @Override
    public void run() { 
        while (true) { 
            produce();
        }
    }
}
　　
(2) 消费者代码：
public class Consumer implements Runnable{ 
    /** * 产品容器 */
    private List<Integer> container;
    private Lock lock;
    /** * 生产者条件 */
    private Condition producerCondition;
    /** * 消费者条件 */
    private Condition consumerCondition;
    public Consumer(List<Integer> container, Lock lock, Condition producerCondition, Condition consumerCondition) { 
        this.container = container;
        this.lock = lock;
        this.producerCondition = producerCondition;
        this.consumerCondition = consumerCondition;
    }
    /** * 消费者消费产品 */
    private void consume(){ 
        try { 
            //获得锁
            lock.lock();
            //容器大小为null，不消费
            if (container.size() == 0) { 
                System.out.println("消费完了。。。。");
                consumerCondition.await();
            }
            Integer p = container.remove(0);
            //模拟1秒消费一个产品
            TimeUnit.MILLISECONDS.sleep(1000);
            System.out.println("消费产品：" + p);
            //消费了，通知生产者
            producerCondition.signal();
        } catch (InterruptedException e) { 
            e.printStackTrace();
        } finally { 
            //释放锁
            lock.unlock();
        }
    }
    @Override
    public void run() { 
        while (true){ 
           consume();
        }
    }
}
　　
(3) 测试代码：
public class ProducerConsumerTest { 
    public static void main(String[] args) { 
        List<Integer> container = new ArrayList<>();
        Lock lock = new ReentrantLock();
        Condition producerCondition = lock.newCondition();
        Condition consumerCondition = lock.newCondition();
        Thread producer = new Thread(new Producer(container,lock,producerCondition,consumerCondition));
        Thread consumer = new Thread(new Consumer(container,lock,producerCondition,consumerCondition));
        producer.start();
        consumer.start();
    }
}