一.概念
- 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);
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();
if (container.size() == 0) {
System.out.println("消费完了。。。。");
consumerCondition.await();
}
Integer p = container.remove(0);
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();
}
}