简介
临近过年了,没什么需求,今天模仿ReentrantLock自定义写了一个自己锁,在这里记录一下,前提是对AQS原理有所了解,分享给大家
1、自定义锁MyLock
package com.jacky; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.AbstractQueuedSynchronizer; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; /** * Created by jacky on 2018/2/12. */ public class MyLock implements Lock{ private final Sync sync; /** * 创建公平锁或非公平锁 * @param fairFlag */ public MyLock(boolean fairFlag){ sync = fairFlag ? new FairSync() : new NonFairSync(); } /** * 默认是公平锁 */ public MyLock(){ sync = new FairSync(); } /** * 获取锁 */ @Override public void lock() { sync.acquire(1); } /** * 获取可中断锁 * @throws InterruptedException */ @Override public void lockInterruptibly() throws InterruptedException { sync.acquireInterruptibly(1); } /** * 它表示用来尝试获取锁,如果获取成功,则返回true,如果获取失败(即锁已被其他线程获取),则返回false, * 也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待 * @return */ @Override public boolean tryLock() { return sync.nonfairTryAcquire(1); } /** * 获得可超时的锁 * @param time * @param unit * @return * @throws InterruptedException */ @Override public boolean tryLock(long time, TimeUnit unit) throws InterruptedException { return sync.tryAcquireNanos(1,unit.toNanos(time)); } /** * 释放锁 */ @Override public void unlock() { sync.release(1); } @Override public Condition newCondition() { return sync.new ConditionObject(); } abstract static class Sync extends AbstractQueuedSynchronizer { /** * 判断当前线程是否获得锁 * @return */ @Override protected boolean isHeldExclusively() { return Thread.currentThread() ==getExclusiveOwnerThread(); } /** * 尝试释放锁 * @param arg * @return */ @Override protected boolean tryRelease(int arg) { int newState =getState()-arg; setState(newState < 0 ? 0:newState); if (newState ==0){ setExclusiveOwnerThread(null); } return true; } final boolean nonfairTryAcquire(int arg) { Thread thread = Thread.currentThread(); int state = getState(); if (state ==0){ compareAndSetState(0,state+arg); //设置独占线程 setExclusiveOwnerThread(thread); return true; } if (isHeldExclusively()){ setState(state+arg); return true; } return false; } } static class FairSync extends Sync{ /** * 尝试公平锁获得锁 * @param arg * @return */ @Override public boolean tryAcquire(int arg) { Thread thread = Thread.currentThread(); int state = getState(); if (state ==0){ //判断队列是否有数据,有数据就返回获取锁失败(公平锁才会这么做) if (hasQueuedPredecessors()){ return false; } compareAndSetState(0,state+arg); //设置独占线程 setExclusiveOwnerThread(thread); return true; } if (isHeldExclusively()){ setState(state+arg); return true; } return false; } } static class NonFairSync extends Sync{ @Override public boolean tryAcquire(int arg) { return nonfairTryAcquire(arg); } } }
2、测试类
package com.jacky; import jdk.internal.org.objectweb.asm.tree.TryCatchBlockNode; import java.util.concurrent.CountDownLatch; import java.util.concurrent.locks.ReentrantLock; /** * Created by jacky on 2018/2/12. */ public class MyLockDemo { private final static MyLock lock = new MyLock(false); //private final static ReentrantLock lock = new ReentrantLock(true); private static int num = 0; public static void main(String[] args) { int count = 2000; CountDownLatch countDownLatch = new CountDownLatch(count); Runnable runnable = new Runnable() { @Override public void run() { try { lock.lock(); Thread thread = Thread.currentThread(); System.out.println("--start--"+thread.getName()); try { Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } num++; System.out.println("--end--"); countDownLatch.countDown(); }finally { lock.unlock(); } } }; Thread thread = null; for (int i = 0; i < count; i++) { thread = new Thread(runnable,"t"+i); thread.start(); } try { countDownLatch.await(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("--num--"+num); } }