在juc包下有一些工具类(如 LockSupport)可以帮助我们实现一个自己的锁。
接下来是具体代码:
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.LockSupport;
/**
* @author liming
* @date 2020-09-24
* @description 手写java锁
* 目前只实现了lock、unlock方法
*/
public class MLock implements Lock {
/**
* AtomicReference包装的变量对其修改是原子性的,不会产生并发问题,内部用CAS实现
*/
private AtomicReference<Thread> owner = new AtomicReference<>();
/**
* 阻塞队列是线程安全的,内部用 ReentrantLock 保证线程安全
*/
private BlockingQueue<Thread> waiters = new LinkedBlockingQueue<>();
@Override
public void lock() {
//用while循环是因为解锁unpark后不能直接运行,要重新抢锁,方可保证锁的互斥性
while (!owner.compareAndSet(null, Thread.currentThread())) {
try {
waiters.put(Thread.currentThread());
} catch (InterruptedException e) {
//真实生产中不要用此方式处理异常,应使用log记日志
e.printStackTrace();
}
LockSupport.park();
}
}
@Override
public void lockInterruptibly() throws InterruptedException {
}
@Override
public boolean tryLock() {
return false;
}
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
return false;
}
@Override
public void unlock() {
if (owner.compareAndSet(Thread.currentThread(), null)) {
while (true) {
Thread next = waiters.poll();
if (next == null) {
break;
}
LockSupport.unpark(next);
}
}
}
@Override
public Condition newCondition() {
return null;
}
}
测试代码:
import org.junit.Test;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
/**
* @author liming
* @date 2020/9/24
* @description
*/
public class MLockTest {
private int count = 0;
private int countWithoutLock = 0;
/**
* 多线程累加 测试锁的效果
*/
@Test
public void multiThreadAdd() throws InterruptedException {
int threadNum = 5;
int circulationNum = 1000;
Lock lock = new MLock();
for (int i = 0; i < threadNum; i++) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
lock.lock();
for (int j = 0; j < circulationNum; j++) {
count++;
}
lock.unlock();
}
});
thread.start();
}
for (int i = 0; i < threadNum; i++) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
for (int j = 0; j < circulationNum; j++) {
countWithoutLock++;
}
}
});
thread.start();
}
TimeUnit.SECONDS.sleep(10);
System.out.println("count = " + count);
System.out.println("countWithoutLock = " + countWithoutLock);
}
}
测试结果:
我们发现,累加结果加锁的符合我们预期,没加锁的结果并不符合预期。