【并发编程】简单易懂的了解ReentrantLock锁的各种机制
ReentrantLock是什么？
- ReentrantLock是一种基于AQS框架的应用实现。
- 是JDK中的一种线程并发访问的同步手段，它的功能类似于synchronized是一种互斥锁，可以保证线程安全。
ReentrantLock与synchronized的区别
- synchronized是JVM层次的锁实现，ReentrantLock是JDK层次的锁实现；
- synchronized的锁状态是无法在代码中直接判断的，但是ReentrantLock可以通过ReentrantLock#isLocked判断；
- synchronized是非公平锁，ReentrantLock是可以是公平也可以是非公平的；
- synchronized是不可以被中断的，而ReentrantLock#lockInterruptibly方法是可以被中断的；
- 在发生异常时synchronized会自动释放锁，而ReentrantLock需要开发者在finally块中显示释放锁；
- ReentrantLock获取锁的形式有多种：如立即返回是否成功的tryLock(),以及等待指定时长的获取，更加灵活；
- synchronized在特定的情况下对于已经在等待的线程是后来的线程先获得锁，而ReentrantLock对于已经在等待的线程是先来的线程先获得锁；
ReentrantLock的使用方式
- 使用的方式
//参数默认false，不公平锁
ReentrantLock lock = new ReentrantLock();
//公平锁
ReentrantLock lock = new ReentrantLock(true);
// 加锁
lock.lock();
try {
//临界区
} finally {
// 解锁
lock.unlock();
}
- 使用实例
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Tset1 {
// 定义数据
private static int sum = 0;
// 定义自己的锁
private static Lock lock = new ReentrantLock();
public static void main(String[] args) throws InterruptedException {
// 循环3吃，开启三个线程
for (int i = 0; i < 3; i++) {
Thread thread = new Thread(() -> {
// 加锁
lock.lock();
try {
// 不加锁这里执行完小于30000
for (int j = 0; j < 10000; j++) {
sum++;
}
} finally {
// 解锁
lock.unlock();
}
});
thread.start();
}
// 等待线程执行完
Thread.sleep(2000);
// 打印最后的结果：30000
System.out.println(sum);
}
}
ReentrantLock的可重入机制
- 减少加锁解锁的过程，然后去提高性能
import java.util.concurrent.locks.ReentrantLock;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class Tset2 {
public static ReentrantLock lock = new ReentrantLock();
public static void main(String[] args) {
// 第一个线程中调用第二个线程、第二个线程中调用第三个线程
method1();
}
public static void method1() {
lock.lock();
try {
log.debug("执行 method1");
method2();
} finally {
lock.unlock();
}
}
public static void method2() {
lock.lock();
try {
log.debug("执行 method2");
method3();
} finally {
lock.unlock();
}
}
public static void method3() {
lock.lock();
try {
log.debug("执行 method3");
} finally {
lock.unlock();
}
}
}
- 执行结果
ReentrantLock的可中断机制（立即中断）
- 应用场景：一个类只需要一个线程去初始化，其他线程初始化完成后当前线程不需要继续处理。
import java.util.concurrent.locks.ReentrantLock;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class Tset3 {
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(() -> {
log.debug("t1启动...");
// 注意： 即使是设置的公平锁，此方法也会立即返回获取锁成功或失败，公平策略不生效
if (!lock.tryLock()) {
log.debug("t1获取锁失败，立即返回false");
return;
}
try {
log.debug("t1获得了锁");
} finally {
lock.unlock();
}
}, "t1");
lock.lock();
try {
log.debug("main线程获得了锁");
t1.start();
// 先让线程t1执行
try {
// 模拟业务
while (true) {
}
} catch (Exception e) {
e.printStackTrace();
}
} finally {
lock.unlock();
}
}
}
- 执行结果
ReentrantLock的锁超时超时失败机制
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class Tset4 {
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(() -> {
log.debug("t1启动...");
// 超时
try {
if (!lock.tryLock(1, TimeUnit.SECONDS)) {
log.debug("等待 1s 后获取锁失败，返回");
return;
}
} catch (InterruptedException e) {
e.printStackTrace();
return;
}
try {
log.debug("t1获得了锁");
} finally {
lock.unlock();
}
}, "t1");
lock.lock();
try {
log.debug("main线程获得了锁");
t1.start();
// 先让线程t1执行
try {
// 模拟业务
while (true) {
}
} catch (Exception e) {
e.printStackTrace();
}
} finally {
lock.unlock();
}
}
}
- 执行结果
ReentrantLock的公平锁方式机制
- new ReentrantLock(true);的时候穿一个true就是公平锁，不传或者传一个false就是非公平锁！
import java.util.concurrent.locks.ReentrantLock;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class Tset5 {
public static void main(String[] args) throws InterruptedException {
ReentrantLock lock = new ReentrantLock(true); // 公平锁
for (int i = 0; i < 500; i++) {
new Thread(() -> {
lock.lock();
try {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
log.debug(Thread.currentThread().getName() + " running...");
} finally {
lock.unlock();
}
}, "t" + i).start();
}
// 1s 之后去争抢锁
Thread.sleep(1000);
for (int i = 0; i < 500; i++) {
new Thread(() -> {
lock.lock();
try {
log.debug(Thread.currentThread().getName() + " running...");
} finally {
lock.unlock();
}
}, "强行插入" + i).start();
}
}
}
-
公平锁运行结果：按照进入的顺序执行，正常顺序日志，无突出的重点，不截图了。
-
非公平锁运行（定义ReentrantLock的时候不传值）结果：出现插队的线程！
ReentrantLock的阻塞唤醒机制
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class Tset6 {
private static ReentrantLock lock = new ReentrantLock();
private static Condition cigCon = lock.newCondition();
private static boolean hashcig = false;
public static void main(String[] args) {
// 定义线程需要被唤醒的线程
new Thread(() -> {
lock.lock();
log.debug("需要被唤醒的线程加锁");
try {
while (!hashcig) {
try {
log.debug("需要被唤醒的线程等待！");
cigCon.await();
} catch (Exception e) {
e.printStackTrace();
}
}
log.debug("需要被唤醒的线程跳出循环！");
} finally {
lock.unlock();
}
}).start();
// 准备要唤醒的线程
new Thread(() -> {
lock.lock();
try {
// 设置条件变了
hashcig = true;
// 唤醒等待线程
cigCon.signal();
} finally {
lock.unlock();
}
}, "t1").start();
}
}
- 运行结果
结束语
- 获取更多有价值的文章，让我们一起成为架构师！
- 关注公众号，可以让你对MySQL有非常深入的了解
- 关注公众号，每天持续高效的了解并发编程！
- 关注公众号，后续持续高效的了解spring源码！
- 这个公众号，无广告！！！每日更新！！！
