简述
我们知道使用ReentrantLock可以实现同步，保证线程安全，下面我们来简单实现自己的Lock
实现
我们最常使用，也最为重要的就是Lock中的lock()和unlock()方法，因此我们只简单实现这两个方法，代码如下
package test;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
/**
* @author baipengfei
* @version 1.0
* @description TODO
* @date 19-1-6 上午11:20
**/
public class MyLock implements Lock {
private boolean isHoldLock = false;
/**
* 同一时刻，只有一个线程获取到锁
*/
@Override
synchronized public void lock() {
if(isHoldLock){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
isHoldLock = true;
}
@Override
synchronized public void unlock() {
notify();
isHoldLock = false;
}
}
当第一个线程进行lock时，跳过if，将isHoldLock设为true，其他线程在lock时就会wait等待，直到调用unlock，notify()将等待的线程唤醒，isHoldLock设为false是因为有可能一个线程速度很快，直接lock到unlock一步完成，过程中没有其他线程调用lock，所以需要保证结束后其他线程可以正常调用lock获得锁
缺点
上述代码简单实现了一个Lock，但是这种Lock不是可重入的，即对象在一个线程内无法再次获得自己内部的锁，如下例子
package test;
import java.util.concurrent.locks.Lock;
/**
* @author baipengfei
* @version 1.0
* @description 测试是否可重入
* @date 19-1-6 上午11:41
**/
public class ReentryDemo {
private Lock lock = new MyLock();
public void methodA(){
lock.lock();
System.out.println("进入方法A");
methodB();
lock.unlock();
}
public void methodB(){
lock.lock();
System.out.println("进入方法B");
lock.unlock();
}
public static void main(String[] args) {
new ReentryDemo().methodA();
}
}
methodA等待methodB结束，而methodB在等待methodA释放锁，导致类似与死锁的情况（其实不是死锁）。
解决
下面我们来继续改进代码，实现可重入性
package test;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
/**
* @author baipengfei
* @version 1.0
* @description TODO
* @date 19-1-6 上午11:20
**/
public class MyLock implements Lock {
private boolean isHoldLock = false;
private Thread holdLockThread = null;
private int reentryCount = 0;
/**
* 同一时刻，只有一个线程获取到锁
*/
@Override
synchronized public void lock() {
if(isHoldLock && Thread.currentThread() != holdLockThread){
//当被锁住时，判断一下是不是同一线程锁的，不是就给我等！
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
holdLockThread = Thread.currentThread();
isHoldLock = true;
reentryCount ++;
}
@Override
synchronized public void unlock() {
//判断当前线程是否是持有锁的线程 是 重入次数-1 否 不作处理
if(holdLockThread == Thread.currentThread()){
reentryCount --;
if (reentryCount == 0){
//全部解锁完毕再唤醒其他线程
notify();
isHoldLock = false;
}
}
}
}
- holdLockThread 用来判断再次lock时，是否是同一线程进行lock，如果不是，就等待吧！
- reentryCount用来判断重入次数，因为重入多次，即lock多次后，必须有相同数量的unlock才算解锁完毕！其他线程才可以拿到锁
