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();
		}
	}
}

  结果：