三.多线程JUC篇-3.10 ReentrantLock

痛定思痛。 2022-12-20 06:10 212阅读 0赞

## 一.概念 ##

*  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();
        }
    }