ReentrantLock功能详解

发布于:2021-11-27 17:10:45

前言

Java里的锁主要分为两种:Synchronized关键字和java.util.concurrent.locks.Lock接口的实现类。之前也写过几篇关于Synchronized的博客:synchronized关键字(一):实现原理。所以本篇主要讲解ReentrantLock功能使用、与Synchronized关键字的区别等等


ReentrantLock

废话不多说,先来看看ReentrantLock的使用。实例中涉及到了线程池和CountDownLatch的简单使用,如果还不太了解,请先简单浏览下这两篇
线程池使用
并发工具三巨头CountDownLatch、CyclicBarrier、Semaphore使用


public class LockDemo {

// 并发线程数量
private static final int THREAD_COUNT = 5;
// 计数变量
private static int count = 0;
private static final Lock lock = new ReentrantLock();
private static final CountDownLatch latch = new CountDownLatch(THREAD_COUNT);

public static void main(String[] args) throws InterruptedException {
ExecutorService executor = Executors.newCachedThreadPool();
for (int i = 0; i < THREAD_COUNT; i++) {
executor.submit(() -> {
for (int j = 0; j < 10000; j++) {
// 加锁
lock.lock();
try {
count++;
} finally {
// 解锁
lock.unlock();
}
}
// 计数器-1操作
latch.countDown();
});
}

// 保证线程池中的任务都执行完成
latch.await();
System.out.println(count);
// 关闭线程池
executor.shutdown();
}
}

执行结果毫无疑问是50000,也就是说ReentrantLock通过lock()unlock()两个方法可以实现和Synchronized关键字同样的效果,并且用法也比较简单。


Condition

ReentrantLock除了单独使用外,还可以与Condition结合使用,实现类似wait/notify机制的效果


public class LockConditionDemo {

public static void main(String[] args) {
final Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();

Thread thread1 = new Thread(() -> {
try {
lock.lock();
System.out.println(System.currentTimeMillis() + " -> thread-1 -> lock()"); // 1
// 模拟耗时操作
Thread.sleep(500);
System.out.println(System.currentTimeMillis() + " -> thread-1 -> await()"); // 2
condition.await();
System.out.println(System.currentTimeMillis() + " -> thread-1 -> continue"); // 6
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
});
Thread thread2 = new Thread(() -> {
try {
lock.lock();
System.out.println(System.currentTimeMillis() + " -> thread-2 -> lock()"); // 3
// 模拟耗时操作
Thread.sleep(200);
System.out.println(System.currentTimeMillis() + " -> thread-2 -> signal()"); // 4
condition.signal();
System.out.println(System.currentTimeMillis() + " -> thread-2 -> continue"); // 5
// 模拟耗时操作
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
});
thread1.start();
thread2.start();
}
}

执行结果


1570171477295 -> thread-1 -> lock()
1570171477797 -> thread-1 -> await()
1570171477797 -> thread-2 -> lock()
1570171477997 -> thread-2 -> signal()
1570171477997 -> thread-2 -> continue
1570171478198 -> thread-1 -> continue

输出顺序已经标记到了每行输出代码的后面,从输出结果可以看出:thread1首先获得锁,执行输出thread-1 -> lock(),休眠500毫秒后执行condition.await(),阻塞thread1,并释放锁。thread2马上获得锁,输出thread-2 -> lock(),休眠200毫秒后执行condition.signal(),唤醒thread1,自己继续执行。此时thread1处于等待锁的状态,只有thread2执行lock.unlock()释放了锁后,thread1才能重新获取锁,继续执行。


可重入性

ReentrantLock翻译过来就是可重入锁,自然是支持可重入的,也很容易验证,示例如下


public class LockDemo {
// 并发线程数量
private static final int THREAD_COUNT = 5;

// 计数变量
private static int count = 0;
private static final Lock lock = new ReentrantLock();
private static final CountDownLatch latch = new CountDownLatch(THREAD_COUNT);

public static void main(String[] args) throws InterruptedException {
ExecutorService executor = Executors.newCachedThreadPool();
for (int i = 0; i < THREAD_COUNT; i++) {
executor.submit(() -> {
for (int j = 0; j < 10000; j++) {
// 加锁
lock.lock();
// 再次加锁
lock.lock();
try {
count++;
} finally {
// 解锁
lock.unlock();
// 再次解锁
lock.unlock();
}
}
// 计数器-1操作
latch.countDown();
});
}
// 保证线程池中的任务都执行完成
latch.await();
System.out.println(count);

// 关闭线程池
executor.shutdown();
}
}

执行结果毫无疑问是50000,这个示例只是把第一个示例稍微修改了一下,分别加锁了2次,解锁了2次。并不会影响输出结果,也没有死锁。这个例子也提醒我们,加锁了多次,一定要解锁同样的次数。


与Synchronized的区别

到现在为止,似乎还只是演示了ReentrantLock和Synchronized同样的功能,Synchronized能做到,ReentrantLock都可以做到。
ReentrantLock与Synchronized的区别主要体现在以下几点:


实现方式:Synchronized由JVM实现,所有JDK版本都支持,ReentrantLock由JDK实现,1.5及以后的版本才有性能差异:JDK1.6在Synchronized中引入了自旋锁、偏向锁、轻量级锁的优化后,性能和ReentrantLock差不多,之前的版本Synchronized效率比ReentrantLock低很多使用方式:Synchronized加锁和解锁都是由JVM自动完成的,ReentrantLock需要手动加锁和解锁ReentrantLock独有的三大功能:
可以指定是公*锁还是非公*锁,Synchronized只能是非公*锁可以结合Condition类实现有条件的分组唤醒,Synchronized结合wait/notify/notifyAll只能随机唤醒一个线程或者全部唤醒提供了能够中断等待锁的线程的机制
ReentrantLock指定公*锁和非公*锁

公*锁和非公*锁描述的是多个线程竞争锁的时候要不要排队,直接排队的就是公*锁;先尝试插队,插队失败再排队的就是非公*锁。其实就是先来后到,和学校食堂吃饭的时候排队一样。理解了公*锁和非公*锁,再来看看ReentrantLock相关的构造方法


public ReentrantLock() {
sync = new NonfairSync();
}

public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}

这是ReentrantLock仅有的2个构造方法,根据第二个可以看出传入boolean类型的参数就可以指定公*锁还是非公*锁,第一个方法可以看出ReentrantLock默认是非公*锁


ReentrantLock结合Condition类实现有条件的分组唤醒

假设有这样一个需求



使用三个线程Thread1、Thread2、Thread3按顺序分别交替打印A、B、C



首先分析需求Thread1打印A时,Thread2、Thread3处于阻塞状态即可,但是Thread1打印完成后需要唤醒Thread2,并且不能唤醒Thread3,再阻塞自己;同理Thread2打印完成后需要唤醒Thread3,但是不能唤醒Thread1,再阻塞自己,依次循环,实现按顺序交替打印,这里明显就需要有条件的唤醒线程。


public class LockConditionDemo {

private static final Lock lock = new ReentrantLock();
private static Condition conditionA = lock.newCondition();
private static Condition conditionB = lock.newCondition();
private static Condition conditionC = lock.newCondition();
private static volatile int permit = 0;

public static void main(String[] args) {

Thread thread1 = new Thread(() -> {
try {
// 休眠200毫秒,验证并不是thread1运气好,才最先输出
Thread.sleep(200);
lock.lock();
for (int i = 0; i < 10; i++) {
while ((permit % 3) != 0) {
conditionA.await();
}
System.out.print("A");
permit++;
conditionB.signal();
}
conditionB.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
});

Thread thread2 = new Thread(() -> {
try {
lock.lock();
for (int i = 0; i < 10; i++) {
while ((permit % 3) != 1) {
conditionB.await();
}
System.out.print("B");
permit++;
conditionC.signal();
}
conditionC.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}

});

Thread thread3 = new Thread(() -> {
try {
lock.lock();
for (int i = 0; i < 10; i++) {
while ((permit % 3) != 2) {
conditionC.await();
}
System.out.print("C");
permit++;
conditionA.signal();
}
conditionA.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
});

thread1.start();
thread2.start();
thread3.start();
}
}

执行结果


ABCABCABCABCABCABCABCABCABCABC

其中三个Condition对象可以决定三个线程应何时被阻塞,何时被唤醒。permit变量是为了确保Thread1最先执行,如果不要求Thread1最先执行(比如:BCABCABCA),也可以不需要permit变量,直接把condition*.await()放在condition*.signal()下面一行即可,对应关系和上述代码一样即可。


ReentrantLock提供了能够中断等待锁的线程的机制

ReentrantLock主要是靠ReentrantLock#lockInterruptibly()方法来提供一种可中断的机制。


public class LockDemo {

private static final Lock lock = new ReentrantLock();

public static void main(String[] args) throws InterruptedException {
Thread thread1 = new Thread(() -> {
try {
lock.lockInterruptibly();
System.out.println(System.currentTimeMillis() + " -> thread-1 获取到了锁");
} catch (InterruptedException e) {
System.out.println(System.currentTimeMillis() + " -> thread-1 被中断");
} finally {
// lock.unlock();
}
});

Thread thread2 = new Thread(() -> {
try {
lock.lockInterruptibly();
System.out.println(System.currentTimeMillis() + " -> thread-2 获取到了锁");
// 等待3秒,证明thread1一直没有获取到锁
Thread.sleep(3000);
System.out.println(System.currentTimeMillis() + " -> thread-2 中断thread-1");
thread1.interrupt();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
});

thread2.start();
// 让thread2先启动,获取锁(仅仅是为了演示,生产环境不要用这种方式让某个线程先启动)
Thread.sleep(200);
thread1.start();
}
}

执行结果


1570180667463 -> thread-2 获取到了锁
1570180670465 -> thread-2 中断thread-1
1570180670465 -> thread-1 被中断

thread-1和thread-2均用lockInterruptibly()方法尝试获取锁,thread-2获取锁后休眠3秒,期间thread-1一直无法获取锁(第9行代码没有输出),此时thread-2调用thread-1的interrupt()方法来中断thread-1,根据输出结果来看,thread-1已经被中断了。这便是ReentrantLock提供的可中断正在等待锁的线程的机制


如何取舍

Synchronized关键字能实现的功能,ReentrantLock都能实现。但是这并不意味着我们在任何时候都要用ReentrantLock,而完全不用Synchronized。Synchronized也有自己的优势:


Synchronized加锁解锁由JVM完成,程序员不会忘记释放锁几乎所有的开发人员都熟悉Synchronized使用Synchronized关键字,生成线程dump文件的时候,能包括锁定信息,能标识死锁或者其他异常问题的来源。而ReentrantLock只是JDK中的一个普通类,JVM并不知道哪些线程拥有Lock对象

基于以上几点,在一般情况下,用Synchronized就行。如果真的需要ReentrantLock的三个高级功能才需要考虑使用ReentrantLock。


总结

以上就是ReentrantLock基本使用,以及和Synchronized关键字的对比,以及如何取舍这两种锁。还是那句话,只有知道了两者的区别和适用场景,才能更好的应对不同的场景,写出更优雅的并发编程代码。

相关推荐

最新更新

猜你喜欢