一、前言
Java通过synchronized关键字来为我们提供线程安全的保证，大多数情况下使用synchronized是没有问题的，然而synchronized有自身的缺陷。例如：当其它线程持有锁时，当前请求获取锁的线程必须等待。等待的时长是无法控制的，而且等待过程中无法响应中断。
正是为了解决synchronized这些的缺陷，Java提供了一个显示锁ReentrantLock来实现线程安全，在满足重入性，独占性的条件下，为我们的加锁，解锁和锁获取提供了灵活的操作。
ReentrantLock的常用方法如下：
lockInterruptibly()：提供响应中断的锁获取操作。
tryLock(long timeout, TimeUtil unit)：指定时间内响应中断和指定时间内的锁获取操作。
tryLock()：以非阻塞的方法尝试获取锁，无论是否获取锁都立刻返回，当成功获取锁返回true，否则返回false。
new ReentrantLock(boolean)：构造方法可指定锁获取的公平性，即先申请获得锁的线程将先获得锁。synchronized是非公平的。
lock()：以阻塞的形式获取锁，和使用synchronized一样的效果。
unlock()：解锁。
isHeldByCurrentThread()：持有锁的线程是否为当前线程。
本文将以ReentrantLock的这些特性为目标，通过synchronized+wait+notify来模拟一个自己的显示锁。代码灵感来源于 汪文君 老师的一书《高并发编程详解:多线程与架构设计》。
二、代码部分
1.定义自己的显示锁，它是一个接口，满足的功能参照备注：
import java.util.List;
import java.util.concurrent.TimeoutException;
public interface MyLock {
/**
* 实现可中断的锁获取操作
*
* @throws InterruptedException
*/
void lock() throws InterruptedException;
/**
* 实现限时的锁获取操作
*
* @param timeMillis
* @throws InterruptedException
* @throws TimeoutException
*/
void lock(long timeMillis) throws InterruptedException, TimeoutException;
/**
* 解锁
*/
void unLock();
/**
* 返回等待获取锁的线程集合
*
* @return
*/
List<Thread> getBlockedThreads();
/**
* 尝试获取锁，获取成功立刻返回true，否则返回false
*
* @return
*/
boolean tryLock();
/**
* 判断当前线程是否持有锁
*
* @return
*/
boolean isHeldByCurrentThread();
}
MyLock接口模拟了ReentrantLock的部分方法：MyLock的lock()方法模拟ReentrantLock的lockInterruptibly()，MyLock的lock(long timeMillis)方法模拟ReentrantLock的tryLock(long timeout, TimeUtil unit)，MyLock的其余方法模拟ReentrantLock的同名方法。
2.定义BooleanLock，作为MyLock的实现类，代码如下：
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.TimeoutException;
public class BooleanLock implements MyLock {
private boolean locked;
private Thread currentThread; //当前持有锁的线程
private final List<Thread> blockedThreads = new ArrayList<>(); //等待获取锁的线程
@Override
public void lock() throws InterruptedException {
synchronized (this) {
while (locked) {
if (!blockedThreads.contains(Thread.currentThread())) {
blockedThreads.add(Thread.currentThread());
}
try {
this.wait();
} catch (InterruptedException e) {
blockedThreads.remove(Thread.currentThread());
throw e;
}
}
locked = true;
currentThread = Thread.currentThread();
blockedThreads.remove(currentThread);
}
}
@Override
public void lock(long timeMillis) throws InterruptedException, TimeoutException {
synchronized (this) {
if (timeMillis <= 0) {
this.lock();
} else {
long remainMills = timeMillis;
long endTime = System.currentTimeMillis() + remainMills; //截至时刻
while (locked) {
if (remainMills <= 0) { //剩余等待时间
throw new TimeoutException("cannot get lock during " + remainMills);
}
if (!blockedThreads.contains(Thread.currentThread())) {
blockedThreads.add(Thread.currentThread());
}
this.wait(remainMills); //等待一定时间
remainMills = endTime - System.currentTimeMillis(); //重新计算等待时间：当前时间点与while执行之前的时间点之差。
}
locked = true;
currentThread = Thread.currentThread();
blockedThreads.remove(currentThread);
}
}
}
@Override
public void unLock() {
synchronized (this) {
if (currentThread == Thread.currentThread()) {
locked = false;
this.notifyAll();
}
}
}
@Override
public List<Thread> getBlockedThreads() {
return Collections.unmodifiableList(blockedThreads);
}
@Override
public boolean tryLock() {
synchronized (this) {
if (!locked) {
locked = true;
currentThread = Thread.currentThread();
blockedThreads.remove(currentThread);
return true;
}
return false;
}
}
@Override
public boolean isHeldByCurrentThread() {
synchronized (this) {
if (Thread.currentThread() == currentThread) {
return true;
}
return false;
}
}
}
三.测试代码
import java.util.Random;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
public class TestMyLock {
private Random random = new Random();
private MyLock myLock = new BooleanLock();
public void syncMethod() {
try {
myLock.lock();
int rand = random.nextInt(10);
System.out.println(Thread.currentThread().getName() + " hold lock, and will sleep " + rand + " seconds");
TimeUnit.SECONDS.sleep(rand);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if (myLock.isHeldByCurrentThread()) {
myLock.unLock();
System.out.println(Thread.currentThread().getName() + " release lock");
}
}
}
public void syncTryMethod() {
try {
if (myLock.tryLock()) {
int rand = random.nextInt(10);
System.out.println(Thread.currentThread().getName() + " hold lock, and will sleep " + rand + " seconds");
TimeUnit.SECONDS.sleep(rand);
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if (myLock.isHeldByCurrentThread()) {
myLock.unLock();
System.out.println(Thread.currentThread().getName() + " release lock");
}
}
}
public void syncMethodOut() {
try {
myLock.lock(1000);
int rand = random.nextInt(10);
System.out.println(Thread.currentThread().getName() + " hold lock, and will sleep " + rand + " seconds");
TimeUnit.SECONDS.sleep(rand);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (TimeoutException e) {
e.printStackTrace();
} finally {
if (myLock.isHeldByCurrentThread()) {
myLock.unLock();
System.out.println(Thread.currentThread().getName() + " release lock");
}
}
}
static void testSync() {
final TestMyLock testMyLock = new TestMyLock();
for (int i = 0; i < 10; i++) {
Thread thread = new Thread(() -> {
testMyLock.syncMethod();
}, i + "");
thread.start();
}
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(testMyLock.myLock.getBlockedThreads());
}
static void testTrySync() {
final TestMyLock testMyLock = new TestMyLock();
for (int i = 0; i < 10; i++) {
Thread thread = new Thread(() -> {
testMyLock.syncTryMethod();
}, i + "");
thread.start();
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(testMyLock.myLock.getBlockedThreads());
}
static void testInterrupt() {
final TestMyLock testMyLock = new TestMyLock();
for (int i = 0; i < 10; i++) {
Thread thread = new Thread(() -> {
testMyLock.syncMethod();
}, i + "");
thread.start();
if (i % 2 == 0) {
thread.interrupt();
}
}
}
static void testTimeOut() throws InterruptedException {
TestMyLock blt = new TestMyLock();
new Thread(blt::syncMethod, "Tl").start();
TimeUnit.MILLISECONDS.sleep(2);
Thread t2 = new Thread(blt::syncMethodOut, "T2");
t2.start();
}
public static void main(String[] args) throws InterruptedException {
testSync();
// testTrySync();
// testInterrupt();
// testTimeOut();
}
}
1.运行testSync()，看到控制台有条不紊的打印出加锁和解锁的操作，说明MyLock实现了线程同步的功能。
0 hold lock, and will sleep 5 seconds
[Thread[1,5,main], Thread[2,5,main], Thread[5,5,main], Thread[4,5,main], Thread[3,5,main], Thread[6,5,main], Thread[7,5,main], Thread[8,5,main], Thread[9,5,main]]
0 release lock
9 hold lock, and will sleep 3 seconds
9 release lock
1 hold lock, and will sleep 3 seconds
1 release lock
8 hold lock, and will sleep 8 seconds
8 release lock
2 hold lock, and will sleep 6 seconds
2 release lock
7 hold lock, and will sleep 6 seconds
7 release lock
5 hold lock, and will sleep 8 seconds
5 release lock
6 hold lock, and will sleep 5 seconds
6 release lock
4 hold lock, and will sleep 3 seconds
4 release lock
3 hold lock, and will sleep 7 seconds
3 release lock2.运行testTrySync()，控制台打印如下，可以看出使用tryLock时，若线程0持有锁，其它线程无法获取锁，故等待获取锁的集合为空集合。
0 hold lock, and will sleep 4 seconds
[]
0 release lock3.运行testInterrupt()，控制台打印如下
java.lang.InterruptedException
0 hold lock, and will sleep 8 seconds
at java.lang.Object.wait(Native Method)
at java.lang.Object.wait(Object.java:502)
0 release lock
at BooleanLock.lock(BooleanLock.java:20)
9 hold lock, and will sleep 4 seconds
at TestMyLock.syncMethod(TestMyLock.java:12)
at TestMyLock.lambda$testInterrupt$2(TestMyLock.java:98)
at java.lang.Thread.run(Thread.java:745)
java.lang.InterruptedException: sleep interrupted
at java.lang.Thread.sleep(Native Method)
at java.lang.Thread.sleep(Thread.java:340)
at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
at TestMyLock.syncMethod(TestMyLock.java:15)
at TestMyLock.lambda$testInterrupt$2(TestMyLock.java:98)
at java.lang.Thread.run(Thread.java:745)
java.lang.InterruptedException
at java.lang.Object.wait(Native Method)
at java.lang.Object.wait(Object.java:502)
at BooleanLock.lock(BooleanLock.java:20)
at TestMyLock.syncMethod(TestMyLock.java:12)
at TestMyLock.lambda$testInterrupt$2(TestMyLock.java:98)
at java.lang.Thread.run(Thread.java:745)
java.lang.InterruptedException
at java.lang.Object.wait(Native Method)
at java.lang.Object.wait(Object.java:502)
at BooleanLock.lock(BooleanLock.java:20)
at TestMyLock.syncMethod(TestMyLock.java:12)
at TestMyLock.lambda$testInterrupt$2(TestMyLock.java:98)
at java.lang.Thread.run(Thread.java:745)
java.lang.InterruptedException
at java.lang.Object.wait(Native Method)
at java.lang.Object.wait(Object.java:502)
at BooleanLock.lock(BooleanLock.java:20)
at TestMyLock.syncMethod(TestMyLock.java:12)
at TestMyLock.lambda$testInterrupt$2(TestMyLock.java:98)
at java.lang.Thread.run(Thread.java:745)
9 release lock
1 hold lock, and will sleep 1 seconds
1 release lock
7 hold lock, and will sleep 0 seconds
7 release lock
3 hold lock, and will sleep 7 seconds
3 release lock
5 hold lock, and will sleep 6 seconds
5 release lock
这里的打印有点乱，要注意e.printStackTrace方法本质上是调用System.err对象的println方法，而System.out.println方法属于System.out对象，故它们是属于不同的对象，也就是线程异步的！可以看出0，2，4，6线程都响应了中断！
4.运行testTimeOut()，控制台打印如，可以看出当线程T1已经获取锁，并且睡眠3s，线程T2尝试在1s内获取锁，结果失败。
Tl hold lock, and will sleep 3 seconds
java.util.concurrent.TimeoutException: cannot get lock during 0
at BooleanLock.lock(BooleanLock.java:42)
at TestMyLock.syncMethodOut(TestMyLock.java:47)
at java.lang.Thread.run(Thread.java:745)
Tl release lock
四、小结
本文演示的案例仅仅是为了更好的理解显示锁特有的性质，ReentrantLock自身的实现运用了大量的AQS和CAS操作，其细节和原理远比本文复杂的多。实际项目开发我们直接使用ReentrantLock即可，不必大费周章定义自己的显示锁。
