Java并发编程：重入锁（ReentranceLock ）、读写锁（ReadWriteLock）代码实现

重入锁：

• 同一时刻只能有一条线程拥有重入锁，但此线程可以重复获得锁。
• 其余需求获得此锁的线程被阻塞。
• 代码实现关键是记录当前获得锁的线程。

public class ReentranceLock {
	//记录当前获得锁的线程。
	private Thread lockedBy = null;
	
	private boolean isLocked = false;
	private int lockCount = 0;

	public synchronized void lock() throws InterruptedException {
		Thread callingThread = Thread.currentThread();
		while (isLocked && lockedBy != callingThread) {
			wait();
		}

		isLocked = true;
		lockedBy = callingThread;
		lockCount++;
		
	}

	public synchronized void unlock() {
		if (Thread.currentThread() == lockedBy) {
			lockCount--;
			if (lockCount == 0) {
				isLocked = false;
				notify();
			}
		}
	}
}

读/写锁：

1.线程获得读锁条件 

• 没有其他线程已获得写锁，并且没有其他线程需求写锁（Read Access） 
• 此线程已获得读锁（Read Reentrance）  
• 此线程已获得写锁（Write to Read Reentrance） 

2.线程获得写锁条件 

• 没有其他线程已获得写锁，或者写锁（Write Access）  
• 此线程已获得写锁（Write Reentrance） 
• 此线程已获得读锁，且为唯一一个线程获得读锁（Read to Write Reentrance）

public class ReadWriteLock {
	
	//多个线程课同时获得读锁，用map记录线程以及对应线程获取锁次数
	private Map<Thread, Integer> readingThreads = new HashMap<>();
	
	//同一时刻，仅有一个线程可以获得写锁
	private Thread writingThread = null;
	//获得写锁的线程获得锁的次数
	private int writers = 0;
	
	//需求写锁的线程数
	private int writeRequests = 0;
	
	
	public synchronized void lockRead() throws InterruptedException {
		Thread callingThread = Thread.currentThread();
		while(!canGrantReadAccess(callingThread)){
			wait();
		}
		
		readingThreads.put(callingThread,  
				(getAccessCount(callingThread) + 1));
	}

	public synchronized void unlockRead() {
		Thread callingThread = Thread.currentThread();
		//当前线程没有获得读锁，抛出异常
		if (!isReader(callingThread)) {
			throw new IllegalMonitorStateException(
					"Calling Thread does not" + " hold a read lock on this ReadWriteLock");
		}
		
		int accessCount = getAccessCount(callingThread);
		if (accessCount == 1) {
			readingThreads.remove(callingThread);
		} else {
			readingThreads.put(callingThread, (accessCount - 1));
		}
		notifyAll();
	}
	
	//此线程是否可以获得读锁
	private boolean canGrantReadAccess(Thread callingThread){
		if(isWriter(callingThread))	return true;
		if(writers > 0) 		return false;
		if(isReader(callingThread))	return true;
		if(writeRequests > 0)      	return false;
		return true;
	}
	
	//此线程是否已经获得读锁
	private boolean isReader(Thread callingThread){
		 return readingThreads.get(callingThread) != null;
	}
	
	//此线程是否已经获得读锁的次数
	private int getAccessCount(Thread callingThread){
		Integer accessCount = readingThreads.get(callingThread);
		if( accessCount == null) return 0;
		return accessCount.intValue();
	}
	
	
	
	public synchronized void lockWrite() throws InterruptedException {
		writeRequests++;
		Thread callingThread = Thread.currentThread();
		while(! canGrantWriteAccess(callingThread)){
			wait();
		}
		writeRequests--;
		writers++;
		writingThread = callingThread;
	}
	
	public synchronized void unlockWrite() throws InterruptedException {
		if(!isWriter(Thread.currentThread())){
		      throw new IllegalMonitorStateException("Calling Thread does not" +
		        " hold the write lock on this ReadWriteLock");
		  }
		writers--;
		if (writers == 0) {
			writingThread = null;
		}
		notifyAll();
	}

	private boolean  canGrantWriteAccess(Thread callingThread){
		if(isOnlyReader(callingThread)) return true;
		if(hasReaders())		return false;
		if(writingThread == null) 	return true;
		if(!isWriter(callingThread)) 	return false;
		return true;
	}
	
	private boolean hasReaders() {
		return readingThreads.size() > 0;
	}

	private boolean isWriter(Thread callingThread) {
		return writingThread == callingThread;
	}
	
	private boolean isOnlyReader(Thread callingThread){
		return readingThreads.size() == 1 && 
				readingThreads.get(callingThread) != null;
	}
}

参考： Java Concurrency / Multithreading Tutorial