模仿ReentrantLock,来手写一把锁。
先上版本一。
package com.itbac.lock; import java.util.Iterator; 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; /** * 手写一把锁 */ public class BacLock implements Lock { /** * 独占资源所有者 */ volatile AtomicReference<Thread> owner = new AtomicReference<>(); /** * 等待的线程 */ volatile LinkedBlockingQueue<Thread> waiters = new LinkedBlockingQueue<>(); @Override public void lock() { //尝试获取锁失败,进入循环 while (!this.tryLock()) { //添加数据到等待队列 waiters.offer(Thread.currentThread()); //线程等待 LockSupport.park(); //线程被唤醒后,从等待集合中移除 waiters.remove(Thread.currentThread()); } } @Override public void lockInterruptibly() throws InterruptedException { } /** * 尝试获取一次锁 * @return */ @Override public boolean tryLock() { //CAS,比较和设置 if (owner.compareAndSet(null, Thread.currentThread())) { return true; } return false; } @Override public boolean tryLock(long time, TimeUnit unit) throws InterruptedException { return false; } @Override public void unlock() { //释放锁成功 if (owner.compareAndSet(Thread.currentThread(), null)) { //迭代等待者并唤醒等待线程 Iterator<Thread> iterator = waiters.iterator(); while (iterator.hasNext()) { Thread next = iterator.next(); if (null != next) { //唤醒线程 LockSupport.unpark(next); } } } } @Override public Condition newCondition() { return null; } }
上面的代码完成了加锁和释放锁的功能。
然后我们需要模仿ReentrantLock ,抽象出一个AQS、
版本二:
AQS
package com.itbac.lock; import java.util.Iterator; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.atomic.AtomicReference; import java.util.concurrent.locks.LockSupport; public abstract class BacAQS { /** * 独占资源所有者 */ volatile AtomicReference<Thread> owner = new AtomicReference<>(); /** * 等待的线程 */ volatile LinkedBlockingQueue<Thread> waiters = new LinkedBlockingQueue<>(); public BacAQS() { } public BacAQS(AtomicReference<Thread> owner, LinkedBlockingQueue<Thread> waiters) { this.owner = owner; this.waiters = waiters; } public boolean tryAcquire() { // 交给使用者去实现。 模板方法设计模式 //不支持的操作异常 throw new UnsupportedOperationException(); } public boolean tryRelease() { throw new UnsupportedOperationException(); } public void acquire(){ //尝试获取锁失败,进入循环 while (!this.tryAcquire()) { //添加数据到等待队列 waiters.offer(Thread.currentThread()); //线程等待 LockSupport.park(); //线程被唤醒后,从等待集合中移除 waiters.remove(Thread.currentThread()); } } public void release(){ //释放锁成功 if (tryRelease()) { //迭代等待者并唤醒等待线程 Iterator<Thread> iterator = waiters.iterator(); while (iterator.hasNext()) { Thread next = iterator.next(); if (null != next) { //唤醒线程 LockSupport.unpark(next); } } } } }
手写lock
package com.itbac.lock; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; /** * 手写一把锁 */ public class BacLock implements Lock { //私有属性 private BacAQS aqs = new BacAQS() { //重写 具体实现逻辑 @Override public boolean tryAcquire() { return owner.compareAndSet(null, Thread.currentThread()); } @Override public boolean tryRelease() { return owner.compareAndSet(Thread.currentThread(), null); } }; //加锁 @Override public void lock() { aqs.acquire(); } /** * 尝试获取一次锁 * @return */ @Override public boolean tryLock() { return aqs.tryAcquire(); } //释放锁 @Override public void unlock() { aqs.release(); } @Override public void lockInterruptibly() throws InterruptedException { } @Override public boolean tryLock(long time, TimeUnit unit) throws InterruptedException { return false; } @Override public Condition newCondition() { return null; } }
先这样了。
原文:https://www.cnblogs.com/itbac/p/11901947.html