MySimpleReadWriteLock

最新推荐文章于 2022-11-16 16:55:13 发布

最新推荐文章于 2022-11-16 16:55:13 发布 · 122 阅读

文章标签：

#ReadWriteLock #AQS例子 #读写锁例子

源码同时被 3 个专栏收录

15 篇文章

订阅专栏

并发源码

10 篇文章

订阅专栏

并发

3 篇文章

订阅专栏

本文介绍了一种简易的读写锁实现方式，通过自定义同步器管理读锁和写锁的状态，确保多线程环境下资源的安全访问。文章详细展示了如何使用 Java 的 `AbstractQueuedSynchronizer` 类来实现自定义的读写锁，并通过测试代码验证其正确性。

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 ....