多线程 - 显式锁-读写锁ReadWriteLock

读写锁，读读可以并发，读写互斥、写写互斥

代码实现了读写HashMap,；

实际开发中，ConcurrentHashMap性能已经很优秀，可以用如下方法实现LinkedHashMap来提高并发访问

package test;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 显示锁<br>
 * 读写锁
 * 
 * 
 * @author ZHEN.L
 * 
 */
public class ReentrantLockTest<K, V> {

	static SimpleDateFormat sdf = new SimpleDateFormat("mm:ss");

	private Map<K, V> map;

	private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
	private Lock readLock = readWriteLock.readLock();
	private Lock writeLock = readWriteLock.writeLock();

	public ReentrantLockTest(Map<K, V> map) {
		this.map = map;
	}

	public V read(K k) {
		readLock.lock();
		try {
			try {
				System.out.println(Thread.currentThread().getName()
						+ " read:begin " + sdf.format(new Date()));
				Thread.sleep(3000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

			return map.get(k);
		} finally {
			System.out.println(Thread.currentThread().getName() + " read:end "
					+ sdf.format(new Date()));
			readLock.unlock();
		}
	}

	public void write(K k, V v) {
		writeLock.lock();
		try {
			try {
				System.out.println(Thread.currentThread().getName()
						+ " write:begin " + sdf.format(new Date()));
				Thread.sleep(3000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			map.put(k, v);
		} finally {
			System.out.println(Thread.currentThread().getName() + " write:end "
					+ sdf.format(new Date()));
			writeLock.unlock();
		}
	}

	public static void main(String[] args) {
		ExecutorService pool = Executors.newFixedThreadPool(10);
		ReentrantLockTest<String, Object> reentrantLockTest = new ReentrantLockTest<String, Object>(
				new HashMap<String, Object>());
		for (int i = 0; i < 10; i++) {
			pool.execute(new ReentrantLockThreadRead(reentrantLockTest));
			pool.execute(new ReentrantLockThreadWrite(reentrantLockTest));
		}
		pool.shutdown();
	}

}

class ReentrantLockThreadRead implements Runnable {

	private ReentrantLockTest<String, Object> reentrantLockTest;

	public ReentrantLockThreadRead(
			ReentrantLockTest<String, Object> reentrantLockTest) {
		this.reentrantLockTest = reentrantLockTest;
	}

	public void run() {
		String k = String.valueOf(Thread.currentThread().getId());
		Object v = reentrantLockTest.read(k);
		// System.out.println(k + " : " + v);
	}
}

class ReentrantLockThreadWrite implements Runnable {

	private ReentrantLockTest<String, Object> reentrantLockTest;

	public ReentrantLockThreadWrite(
			ReentrantLockTest<String, Object> reentrantLockTest) {
		this.reentrantLockTest = reentrantLockTest;
	}

	public void run() {
		String k = String.valueOf(Thread.currentThread().getId());
		Object v = Thread.currentThread().getName();
		reentrantLockTest.write(k, v);
	}
}