MySimpleReadWriteLock-优快云博客

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;


public class MySimpleReadWriteLock {

	private Syn syn = new Syn();
	private Lock readLock = new ReadLock(syn);
	private Lock writeLock = new WriteLock(syn);

	public MySimpleReadWriteLock() {
		
	}
	
	private static class ReadLock implements Lock {
		final private Syn syn;
		public ReadLock(Syn syn) {
			this.syn = syn;
		}
		@Override
		public void lock() {
			syn.acquireShared(1);
		}
		@Override
		public void lockInterruptibly() throws InterruptedException {
			syn.acquireInterruptibly(1);
		}
		@Override
		public boolean tryLock() {
			return syn.justTryAcquire(1);
		}
		@Override
		public boolean tryLock(long time, TimeUnit unit)
				throws InterruptedException {
			return syn.tryAcquireNanos(1, unit.toNanos(time));
		}
		@Override
		public void unlock() {
			syn.release(1);
		}
		@Override
		public Condition newCondition() {
			return syn.newCondition();
		}
	}
	
	private static class WriteLock implements Lock{
		private final Syn syn;
		public WriteLock(Syn syn) {
			this.syn = syn;
		}
		@Override
		public void lock() {
			syn.acquire(1);
		}
		@Override
		public void lockInterruptibly() throws InterruptedException {
			syn.acquireInterruptibly(1);
		}
		@Override
		public boolean tryLock() {
			return syn.justTryAcquire(1);
		}
		@Override
		public boolean tryLock(long time, TimeUnit unit)
				throws InterruptedException {
			return syn.tryAcquireNanos(1, unit.toNanos(time));
		}
		@Override
		public void unlock() {
			syn.release(1);
		}
		@Override
		public Condition newCondition() {
			return syn.newCondition();
		}
	}

	private static class Syn extends AbstractQueuedSynchronizer {

		private static final long serialVersionUID = 1L;
		private static final int SHARED_SHIFT = 16;
		private static final int SHARED_UNIT = 1 << SHARED_SHIFT;
		private static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;
		private static final HoldCounterThreadLocal LOCAL = new HoldCounterThreadLocal();
		private HoldCounter holdCounter = null;
		
		private static class HoldCounterThreadLocal extends ThreadLocal<HoldCounter>{
			@Override
			protected MySimpleReadWriteLock.Syn.HoldCounter initialValue() {
				return new HoldCounter();
			}
		}
		
		private static class HoldCounter {
			int i = 0;
			long tid = Thread.currentThread().getId();
			public int decrement(int arg) {
				return i-=arg;
			}
			
			public int increment(int acquires) {
				return i+=acquires;
			}
		}

		@Override
		protected int tryAcquireShared(int acquires) {
			int state = super.getState();
			Thread current = Thread.currentThread();
			int exclusiveCount = exclusiveCount(state);
			if(exclusiveCount != 0 && current != getExclusiveOwnerThread()) {//current != getExclusiveOwnerThread()  保证写锁可以让读锁进
				return -1;
			}
			int c = state + (acquires<<SHARED_SHIFT);
			if(compareAndSetState(state, c)) {
				HoldCounter hc = holdCounter;
				if(hc == null || hc.tid != current.getId() ) {//holdCounter.tid != current.getId()  利用的底层的缓存,导致每个线程可能看到的holdCounter是不一样的，很有可能是自己的，也有可能是其他线程的
					holdCounter = hc = LOCAL.get();
				}
				hc.increment(acquires);
				return 1;
			}
			
			return -1;
		}
		private int exclusiveCount(int state) {
			return EXCLUSIVE_MASK & state;
		}

		@Override
		protected boolean tryReleaseShared(int arg) {
			Thread current = Thread.currentThread();
			HoldCounter hc = holdCounter;
			if(hc == null || hc.tid != current.getId()) {
				holdCounter = hc = LOCAL.get();
			}
			if(hc.i-arg < 0)
				throw new IllegalMonitorStateException("release arg is illegal");
			else 
				hc.decrement(arg);
			
			for(;;) {	//独占模式下的release不用for(;;) 因为只要判断了current和exclusiveOwnerThead就可以		 但是共享模式下的，由于release可能会并发执行，需要保证原子操作，就for和cas
				int state = getState();
				int nextc = state - (arg<<SHARED_SHIFT);
				if(compareAndSetState(state, nextc)) {
					return nextc == 0; 
				}
			}
		}

		@Override
		protected boolean tryAcquire(int acquires) {
			return justTryAcquire(acquires);
		}

		private boolean justTryAcquire(int acquires) {
			int state = super.getState();
			int w = exclusiveCount(state);
			Thread current = Thread.currentThread();
			if(state==0) {
				if(super.compareAndSetState(state, state+acquires)) {
					setExclusiveOwnerThread(current);
					return true;
				}
			} else if(w==0 || current!=getExclusiveOwnerThread()) {
				return false;
			} else {
				if(compareAndSetState(state, state+acquires)) {
					return true;
				}
			}
			return false;
		}

		@Override
		protected boolean tryRelease(int arg) {
			Thread current = Thread.currentThread();
			if(current!=getExclusiveOwnerThread()) {
				throw new IllegalMonitorStateException("release error");
			}
			int p = super.getState();
			int c = p-arg;
			if(c==0) {
				setState(c);
				setExclusiveOwnerThread(null);
				return true;
			} else {
				setState(c);
				return false;
			}
		}
		
		public Condition newCondition() {
			return new ConditionObject();
		}

		@Override
		protected boolean isHeldExclusively() {
			return getExclusiveOwnerThread() == Thread.currentThread();
		}
		
	}
	
	public Lock readLock() {
		return readLock;
	}
	
	public Lock writeLock() {
		return writeLock;
	}
	
	public boolean tryLock() {
		return syn.justTryAcquire(1);
	}
	
	public void lock() {
		syn.acquire(1);
	}
	
	public void unlock() {
		syn.release(1);
	}
	
}

import java.util.concurrent.locks.Lock;


public class MySimpleRWLockTest {
	static Lock readLock = null;
	static Lock writeLock = null;
	static {
		MySimpleReadWriteLock lock = new MySimpleReadWriteLock();
		readLock = lock.readLock();
		writeLock = lock.writeLock();
	}

	public static void main(String[] args) {
		writeLockTest();
		readLockTest();
	}

	private static void writeLockTest() {
		TestWorker worker = new TestWorker() {
			@Override
			public void exe() {
				System.out.println("..........start write ....");
				writeLock.lock();
				try {
					System.out.println("enter write ....");
					Thread.sleep(2000);
					System.out.println("exit write ....");
				} catch (Exception e) {
				} finally {
					writeLock.unlock();
				}
			}
		};
		worker.printTakeTimeMutil(2);
	}

	private static void readLockTest() {
		TestWorker worker = new TestWorker() {
			@Override
			public void exe() {
				System.out.println("..........start read ....");
				readLock.lock();
				try {
					System.out.println("enter read ....");
					Thread.sleep(1000);
					System.out.println("exit read ....");
				} catch (Exception e) {
				} finally {
					readLock.unlock();
				}
			}
		};
		worker.printTakeTimeMutil(5);
	}

}

..........start write ....

..........start read ....

enter write ....

..........start read ....

..........start write ....

..........start read ....

exit write ....

enter read ....

exit read ....

enter write ....

exit write ....

enter read ....