读写锁ReentrantReadWriteLock

实例：

public class ReentrantReadWriteLockTest {
private static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
//private static ReentrantLock lock = new ReentrantLock();
private static ReadLock readLock = lock.readLock();
private static WriteLock writeLock = lock.writeLock();
private static Map<String,String> map = new HashMap<String,String>();

//减数门栓，减为零后就不计算了
private static CountDownLatch latch = new CountDownLatch(102);

//周期循环的屏障。加到102后，从0开始计算
private static CyclicBarrier barrier = new CyclicBarrier(102);

public static void main(String[] args) throws InterruptedException{

long beginTime = System.currentTimeMillis();

for(int i = 0 ; i < 100 ; i++){
new Thread(new ReadThread()).start();
}
for(int i = 0 ; i < 2 ; i++){
new Thread(new WriteThread()).start();
}
latch.await();
long endTime = System.currentTimeMillis();

System.out.println("一共使用了" + (endTime-beginTime) + "ms");

}

static class WriteThread implements Runnable{
public void run(){
try {
//相当于把所用读写线程放到同一水平线上在开始真正的计算
barrier.await();
}
catch (Exception e) {
e.printStackTrace();
}

try {
//加在对象上的锁
writeLock.lock();
//lock.lock();
map.put("1", "2");
Thread.sleep(100);			}
catch (Exception e) {
e.printStackTrace();
}
finally{
writeLock.unlock();

//lock.unlock();
}
//latch把计数加一
latch.countDown();

}
}

static class ReadThread implements Runnable{
public void run(){
try {
//相当于把所用读写线程放到同一水平线上在开始真正的计算
barrier.await();
}
catch (Exception e) {
e.printStackTrace();
}

try {
//加在ReentrantReadWriteLockTest对象上的锁
readLock.lock();
//lock.lock();
//System.out.println(this.toString());
map.get("1");
Thread.sleep(100);			}
catch (Exception e) {
e.printStackTrace();
}
finally{
readLock.unlock();
//lock.unlock();

}
latch.countDown();

}
}
}

注意：