JAVA多线程-Lock的使用（四）-读写锁ReentrantReadWriteLock

读写锁ReentrantReadWriteLock

我们之前讲解的ReentrantLock具有完全互斥排他的效果，即同一时间只有一个线程在执行lock()方法后面的任务。这样做虽然保证了实例变量的线程安全性，但效率是非常低下的。

而ReentrantReadWriteLock类，使用它可以加快运行效率，在某些不需要操作实例变量的方法中，完全可以使用读写锁来提升该方法的代码运行效率。

读写锁：有两个锁，一个是都操作相关的锁，也称为共享锁；另一个是写操作相关的锁，也叫排他锁。换句话来讲，多个读锁之间不互斥，读锁与写锁互斥，写锁与写锁互斥。

1、读读共享

package org.jksoft.thread.ReentrantReadWriteLock;

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

/**
* 测试一：读读共享
* @author mcl
*
* 2016-2-21-下午3:18:28
*/
public class Test1 {
public static void main(String[] args) {
MyService service = new MyService();
new MyThread(service).start();
new MyThread(service).start();
}
}
class MyThread extends Thread{
private MyService service;
public MyThread(MyService service){
this.service = service;
}
public void run(){
service.test();
}
}
class MyService{
private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
public void test(){
lock.readLock().lock();
System.out.println(Thread.currentThread().getName()+":在"+System.currentTimeMillis()+"时获取了锁定");
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
finally{
lock.readLock().unlock();
}
}
}

结果：



2、读写/写读互斥

package org.jksoft.thread.ReentrantReadWriteLock;

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

/**
* 测试二：读写/写读互斥
* @author mcl
*
* 2016-2-21-下午3:18:28
*/
public class Test2 {
public static void main(String[] args) {
MyService2 service = new MyService2();
new MyThread2(service).start();
new MyThread3(service).start();
}
}
class MyThread2 extends Thread{
private MyService2 service;
public MyThread2(MyService2 service){
this.service = service;
}
public void run(){
service.read();
}
}
class MyThread3 extends Thread{
private MyService2 service;
public MyThread3(MyService2 service){
this.service = service;
}
public void run(){
service.write();
}
}
class MyService2{
private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
public void read(){
lock.readLock().lock();
System.out.println(Thread.currentThread().getName()+":在"+System.currentTimeMillis()+"时获取了锁定");
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
finally{
lock.readLock().unlock();
}
}
public void write(){
lock.writeLock().lock();
System.out.println(Thread.currentThread().getName()+":在"+System.currentTimeMillis()+"时获取了锁定");
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
finally{
lock.writeLock().unlock();
}
}
}

结果：



3、写写互斥

package org.jksoft.thread.ReentrantReadWriteLock;

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

/**
* 测试三：写写互斥
* @author mcl
*
* 2016-2-21-下午3:18:28
*/
public class Test3 {
public static void main(String[] args) {
MyService3 service = new MyService3();
new MyThread5(service).start();
new MyThread6(service).start();
}
}
class MyThread6 extends Thread{
private MyService3 service;
public MyThread6(MyService3 service){
this.service = service;
}
public void run(){
service.read();
}
}
class MyThread5 extends Thread{
private MyService3 service;
public MyThread5(MyService3 service){
this.service = service;
}
public void run(){
service.write();
}
}
class MyService3{
private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
public void read(){
lock.writeLock().lock();
System.out.println(Thread.currentThread().getName()+":在"+System.currentTimeMillis()+"时获取了锁定");
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
finally{
lock.writeLock().unlock();
}
}
public void write(){
lock.writeLock().lock();
System.out.println(Thread.currentThread().getName()+":在"+System.currentTimeMillis()+"时获取了锁定");
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
finally{
lock.writeLock().unlock();
}
}
}

结果：