ReentrantReadWriteLock

1.

（1）读操作（共享锁）之间不互斥，写操作（排他锁）之间互斥，读和写操作之间互斥，提高ReentrantLock的效率

（2）可重入：按照ReentrantLock样式重新获取读写锁，但是在写入线程保持的写入锁释放后，才允许重入读线程

（3）锁降级：写线程可以获得读取锁，即先获得写入锁再获得读锁，释放时先读后写，但是从读取锁升级到写入锁是不可能的

（4）中断：读和写锁都支持获取期间中断

（5）Condition：写入锁提供了一个Condition的实现，读取锁不支持

（1）读不互斥 、读写互斥、写写互斥

读操作 共享锁	Thread-0	1490764712057  ab几乎同时进入读
读操作 共享锁	Thread-1	1490764712068
读取完毕	Thread-0	1490764722058
读取完毕	Thread-1	1490764722069

读操作 共享锁	Thread-0	1490765050349
读取完毕	Thread-0	1490765053349
写操作 排他锁	Thread-1	1490765053349
写入完毕	Thread-1	1490765056349

写操作 排他锁	Thread-0	1490765106874
写入完毕	Thread-0	1490765109874
写操作 排他锁	Thread-1	1490765109874
写入完毕	Thread-1	1490765112874

/**
* @Title: Run.java
* @Package lock
* @Description: 关于ReentrantLock的相关测试
* @author LingLee
* @date 2017年3月29日 上午9:33:34
* @version V1.0
*/
package lock;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
*
* @Title: Service
* @Description:
*/
class Service{
private ReentrantReadWriteLock lock=new ReentrantReadWriteLock();
public void read(){
try{
lock.readLock().lock();
System.out.println("读操作 共享锁\t"+Thread.currentThread().getName()+"\t"+System.currentTimeMillis());
Thread.sleep(3000);
System.out.println("读取完毕\t"+Thread.currentThread().getName()+"\t"+System.currentTimeMillis());
}catch(InterruptedException e){
e.printStackTrace();
}finally{
lock.readLock().unlock();
}
}
public void write(){
try{
lock.writeLock().lock();
System.out.println("写操作 排他锁\t"+Thread.currentThread().getName()+"\t"+System.currentTimeMillis());
Thread.sleep(3000);
System.out.println("写入完毕\t"+Thread.currentThread().getName()+"\t"+System.currentTimeMillis());
}catch(InterruptedException e){
e.printStackTrace();
}finally{
lock.writeLock().unlock();
}
}
}

class ThreadA extends Thread{
private Service service;
public ThreadA(Service service){
this.service=service;
}
public void run(){
//service.read();
service.write();
}
}

class ThreadB extends Thread{
private Service service;
public ThreadB(Service service){
this.service=service;
}
public void run(){
//service.read();
service.write();
}
}
/**
* @Title: Run
* @Description: 测试类
*/
public class Run {

public static void main(String[] args) throws InterruptedException{
Service s=new Service();
ThreadA  a=new ThreadA(s);
a.start();
ThreadB b=new ThreadB(s);
b.start();
}
}