ReentrantReadWriteLock读写锁的使用

　　类ReentrantLock具有完全互斥排他的效果，即同一时间只有一个线程在执行ReentrantLock.lock()后面的代码。这样虽然保证了线程的安全性，但是效率低下。JDK提供了ReentrantReadWriteLock读写锁，使用它可以加快效率，在某些不需要操作实例变量的方法中，完全可以使用读写锁ReemtrantReadWriteLock来提升该方法的运行速度。

　　读写锁表示有两个锁，一个是读操作相关的锁，也称为共享锁；另一个是写操作相关的锁，也叫排他锁。也就是多个读锁之间不互斥，读锁与写锁互斥、写锁与写锁互斥。在没有线程Thread进行写入操作时，进行读取操作的多个Thread都可以获取读锁，而进行写入操作的Thread只有在获取写锁后才能进行写入操作。即多个Thread可以同时进行读取操作，但是同一时刻只允许一个Thread进行写入操作。

1.读读共享

　　读锁与读锁可以共享，这种锁一般用于只读操作，不对变量进行修改操作。

package cn.qlq.thread.twelve;import java.util.concurrent.locks.ReentrantReadWriteLock;import org.slf4j.Logger;
import org.slf4j.LoggerFactory;import cn.qlq.thread.one.RunnableThread;public class Demo1 {private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();// 读写锁private static final Logger log = LoggerFactory.getLogger(Demo1.class);private int i;public String readI() {try {lock.readLock().lock();// 占用读锁log.info("threadName -> {} 占用读锁,i->{}", Thread.currentThread().getName(), i);Thread.sleep(2 * 1000);} catch (InterruptedException e) {} finally {log.info("threadName -> {} 释放读锁,i->{}", Thread.currentThread().getName(), i);lock.readLock().unlock();// 释放读锁
        }return i + "";}public static void main(String[] args) {final Demo1 demo1 = new Demo1();Runnable runnable = new Runnable() {@Overridepublic void run() {demo1.readI();}};new Thread(runnable, "t1").start();new Thread(runnable, "t2").start();new Thread(runnable, "t3").start();}}

结果:

18:27:20 [cn.qlq.thread.twelve.Demo1]-[INFO] threadName -> t2 占用读锁,i->0
18:27:20 [cn.qlq.thread.twelve.Demo1]-[INFO] threadName -> t1 占用读锁,i->0
18:27:20 [cn.qlq.thread.twelve.Demo1]-[INFO] threadName -> t3 占用读锁,i->0
18:27:22 [cn.qlq.thread.twelve.Demo1]-[INFO] threadName -> t3 释放读锁,i->0
18:27:22 [cn.qlq.thread.twelve.Demo1]-[INFO] threadName -> t1 释放读锁,i->0
18:27:22 [cn.qlq.thread.twelve.Demo1]-[INFO] threadName -> t2 释放读锁,i->0

2.写写互斥

　　写锁与写锁互斥，这就类似于ReentrantLock的作用效果。

package cn.qlq.thread.twelve;import java.util.concurrent.locks.ReentrantReadWriteLock;import org.slf4j.Logger;
import org.slf4j.LoggerFactory;public class Demo2 {private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();// 读写锁private static final Logger log = LoggerFactory.getLogger(Demo2.class);private int i;public void addI() {try {lock.writeLock().lock();// 占用写锁log.info("threadName -> {} 占用写锁,i->{}", Thread.currentThread().getName(), i);Thread.sleep(2 * 1000);i++;} catch (InterruptedException e) {} finally {log.info("threadName -> {} 释放写锁,i->{}", Thread.currentThread().getName(), i);lock.writeLock().unlock();// 释放写锁
        }}public static void main(String[] args) {final Demo2 demo1 = new Demo2();Runnable runnable = new Runnable() {@Overridepublic void run() {demo1.addI();}};new Thread(runnable, "t1").start();new Thread(runnable, "t2").start();new Thread(runnable, "t3").start();}}

结果:(从时间可以看出实现了互斥效果)

18:31:31 [cn.qlq.thread.twelve.Demo2]-[INFO] threadName -> t1 占用写锁,i->0
18:31:33 [cn.qlq.thread.twelve.Demo2]-[INFO] threadName -> t1 释放写锁,i->1
18:31:33 [cn.qlq.thread.twelve.Demo2]-[INFO] threadName -> t2 占用写锁,i->1
18:31:35 [cn.qlq.thread.twelve.Demo2]-[INFO] threadName -> t2 释放写锁,i->2
18:31:35 [cn.qlq.thread.twelve.Demo2]-[INFO] threadName -> t3 占用写锁,i->2
18:31:37 [cn.qlq.thread.twelve.Demo2]-[INFO] threadName -> t3 释放写锁,i->3

3.读写互斥

package cn.qlq.thread.twelve;import java.util.concurrent.locks.ReentrantReadWriteLock;import org.slf4j.Logger;
import org.slf4j.LoggerFactory;/*** 读写互斥* * @author Administrator**/
public class Demo3 {private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();// 读写锁private static final Logger log = LoggerFactory.getLogger(Demo3.class);private int i;public String readI() {try {lock.readLock().lock();// 占用读锁log.info("threadName -> {} 占用读锁,i->{}", Thread.currentThread().getName(), i);Thread.sleep(2 * 1000);} catch (InterruptedException e) {} finally {log.info("threadName -> {} 释放读锁,i->{}", Thread.currentThread().getName(), i);lock.readLock().unlock();// 释放读锁
        }return i + "";}public void addI() {try {lock.writeLock().lock();// 占用写锁log.info("threadName -> {} 占用写锁,i->{}", Thread.currentThread().getName(), i);Thread.sleep(2 * 1000);i++;} catch (InterruptedException e) {} finally {log.info("threadName -> {} 释放写锁,i->{}", Thread.currentThread().getName(), i);lock.writeLock().unlock();// 释放写锁
        }}public static void main(String[] args) throws InterruptedException {final Demo3 demo1 = new Demo3();new Thread(new Runnable() {@Overridepublic void run() {demo1.readI();}}, "t1").start();Thread.sleep(1 * 1000);new Thread(new Runnable() {@Overridepublic void run() {demo1.addI();}}, "t2").start();}}

结果:

18:34:59 [cn.qlq.thread.twelve.Demo3]-[INFO] threadName -> t1 占用读锁,i->0
18:35:01 [cn.qlq.thread.twelve.Demo3]-[INFO] threadName -> t1 释放读锁,i->0
18:35:01 [cn.qlq.thread.twelve.Demo3]-[INFO] threadName -> t2 占用写锁,i->0
18:35:03 [cn.qlq.thread.twelve.Demo3]-[INFO] threadName -> t2 释放写锁,i->1

4.写读互斥

　　写锁与读锁也是互斥的。先占用写锁后读锁进行抢占也会等待写锁释放。

package cn.qlq.thread.twelve;import java.util.concurrent.locks.ReentrantReadWriteLock;import org.slf4j.Logger;
import org.slf4j.LoggerFactory;/*** 读写互斥* * @author Administrator**/
public class Demo3 {private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();// 读写锁private static final Logger log = LoggerFactory.getLogger(Demo3.class);private int i;public String readI() {try {lock.readLock().lock();// 占用读锁log.info("threadName -> {} 占用读锁,i->{}", Thread.currentThread().getName(), i);Thread.sleep(2 * 1000);} catch (InterruptedException e) {} finally {log.info("threadName -> {} 释放读锁,i->{}", Thread.currentThread().getName(), i);lock.readLock().unlock();// 释放读锁
        }return i + "";}public void addI() {try {lock.writeLock().lock();// 占用写锁log.info("threadName -> {} 占用写锁,i->{}", Thread.currentThread().getName(), i);Thread.sleep(2 * 1000);i++;} catch (InterruptedException e) {} finally {log.info("threadName -> {} 释放写锁,i->{}", Thread.currentThread().getName(), i);lock.writeLock().unlock();// 释放写锁
        }}public static void main(String[] args) throws InterruptedException {final Demo3 demo1 = new Demo3();new Thread(new Runnable() {@Overridepublic void run() {demo1.addI();}}, "t2").start();Thread.sleep(1 * 1000);new Thread(new Runnable() {@Overridepublic void run() {demo1.readI();}}, "t1").start();}}

结果:

18:36:14 [cn.qlq.thread.twelve.Demo3]-[INFO] threadName -> t2 占用写锁,i->0
18:36:16 [cn.qlq.thread.twelve.Demo3]-[INFO] threadName -> t2 释放写锁,i->1
18:36:16 [cn.qlq.thread.twelve.Demo3]-[INFO] threadName -> t1 占用读锁,i->1
18:36:18 [cn.qlq.thread.twelve.Demo3]-[INFO] threadName -> t1 释放读锁,i->1