读写锁操作

说到ReentrantReadWriteLock,首先要做的是与ReentrantLock划清界限.它和后者都是单独的实现,彼此之间没有继承或实现的关系.然后就是总结这个锁机制的特性了:

(a).重入方面其内部的WriteLock可以获取ReadLock,但是反过来ReadLock想要获得WriteLock则永远都不要想.

(b).WriteLock可以降级为ReadLock,顺序是:先获得WriteLock再获得ReadLock,然后释放WriteLock,这时候线程将保持Readlock的持有.反过来ReadLock想要升级为WriteLock则不可能,为什么?参看(a),呵呵.

(c).ReadLock可以被多个线程持有并且在作用时排斥任何的WriteLock,而WriteLock则是完全的互斥.这一特性最为重要,因为对于高读取频率而相对较低写入的数据结构,使用此类锁同步机制则可以提高并发量.

(d).不管是ReadLock还是WriteLock都支持Interrupt,语义与ReentrantLock一致.

(e).WriteLock支持Condition并且与ReentrantLock语义一致,而ReadLock则不能使用Condition,否则抛出UnsupportedOperationException异常.

ReentrantReadWriteLock竞争条件

ReentrantReadWriteLock会使用两把锁来解决问题,一个读锁,一个写锁

线程进入读锁的前提条件:
没有其他线程的写锁,
没有写请求或者有写请求,但调用线程和持有锁的线程是同一个

线程进入写锁的前提条件:
没有其他线程的读锁
没有其他线程的写锁

 

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

public class ReentrantReadWriteLockSample {
	public static void main(String[] args) {
		testReadLock();
		//testWriteLock();
		}
	public static void testReadLock() {
		final ReadWriteLockSampleSupport support = new ReadWriteLockSampleSupport();
		support.initCache();
		Runnable runnable = new Runnable() {
			public void run() {
				support.get("test");
				}
			};
			new Thread(runnable).start();
			new Thread(runnable).start();
			new Thread(new Runnable() {
				public void run() {
					support.put("test", "test");
					}
				}).start();
			}
	public static void testWriteLock() {
		final ReadWriteLockSampleSupport support = new ReadWriteLockSampleSupport();
		support.initCache();
		new Thread(new Runnable() {
			public void run() {
				support.put("key1", "value1");
				}
			}).start();
		new Thread(new Runnable() {
			public void run() {
				support.put("key2", "value2");
				}
			}).start();
		new Thread(new Runnable() {
			public void run() {
				support.get("key1");
				}
			}).start();
		}
	}
class ReadWriteLockSampleSupport {
	private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
	private final Lock readLock = lock.readLock();
	private final Lock writeLock = lock.writeLock();
	private volatile boolean completed;
	private Map<String,String> cache;
	public void initCache() {
		readLock.lock();
		if(!completed) {
			// Must release read lock before acquiring write lock                            
			//必须释放锁之前获得读写锁
			readLock.unlock(); // (1)
			writeLock.lock(); // (2)                            
			// Recheck state because another thread might have acquired                             
			//检查状态，因为另一个线程可能获得                            
			// write lock and changed state before we did.                            
			//写锁和状态改变之前，我们所做的。
			if(!completed) {
				cache = new HashMap<String,String>(32);
				completed = true;
				}
			// Downgrade by acquiring read lock before releasing write lock                            
			//获得读锁之前释放写锁
			readLock.lock(); // (3)
			writeLock.unlock(); // (4) Unlock write, still hold read
			}
		System.out.println("empty? " + cache.isEmpty());
		readLock.unlock();
		}
	public String get(String key) {
		readLock.lock();
		System.out.println(Thread.currentThread().getName() + " read.");
		startTheCountdown();
		try{
			return cache.get(key);
			}
		finally{
			readLock.unlock();
			}
		}
	public String put(String key, String value) {
		writeLock.lock();
		System.out.println(Thread.currentThread().getName() + " write.");
		startTheCountdown();
		try{
			return cache.put(key, value);
			}finally {
				writeLock.unlock();
				}
			}
	/**
	 * A simple countdown,it will stop after about 5s. 
	 */
	public void startTheCountdown() {
		long currentTime = System.currentTimeMillis();
		for(;;) {
			long diff = System.currentTimeMillis() - currentTime;
			if(diff > 5000) {
				break;
				}
			}
	}
}

 

这个例子改造自JDK的API提供的示例,其中ReadWriteLockSampleSupport辅助类负责维护一个Map,当然前提是这个Map大部分的多线程下都是读取,只有很少的比例是多线程竞争修改Map的值.其中的initCache()简单的说明了特性(a),(b).在这个方法中如果把注释(1)和(2)处的代码调换位置,就会发现轻而易举的死锁了,当然是因为特性(1)的作用了.而注释(3),(4)处的代码位置则再次证明了特性 (a),并且有力的反映了特性(b)--WriteLock在cache初始化完毕之后,降级为ReadLock.另外get(),put()方法在线程获取锁之后会在方法中呆上近5s的时间.

ReentrantReadWriteLockSample中的两个静态测试方法则分别测试了ReadLock和WriteLock的排斥性. testReadLock()中,开启三个线程,前两者试图获取ReadLock而后者去获取WriteLock.执行结果可以看到:ReadWriteLockSampleSupport的get()方法中的打印结果在前两个线程中几乎同时显示,而put()中的打印结果则要等上近5s.这就说明了,ReadLock可以多线程持有并且排斥WriteLock的持有线程.testWriteLock()中,也开启三个线程.前两个是去获取WriteLock,最后一个获取ReadLock.执行的结果是三个打印结果都有近5s的间隔时间,这说明了WriteLock是独占的,比较独!

使用ReentrantReadWriteLock可以推广到大部分读,少量写的场景,因为读线程之间没有竞争,所以比起sychronzied,性能好很多.
如果需要较为精确的控制缓存,使用ReentrantReadWriteLock倒也不失为一个方案.

-----------------------------------------------------第二个例子-----------------------------------------------------------------------

 

读任务

package cn.itcast.heima.readwritelock;
//可执行任务
public class ReadTask extends Thread {
  //logic bean
  private ReadWriteLockLogic readWriteLockOperator;
 
  //读者
  private String reader;

  public ReadTask(ReadWriteLockLogic readWriteLockOperator, String reader) {
    this.readWriteLockOperator = readWriteLockOperator;
    this.reader = reader; 
  }
 
  private ReadTask(){}

  // 执行任务
  public void run() {
    if(this.readWriteLockOperator != null){
      try {
        while(!isInterrupted()){
          Thread.sleep(200);
          System.out.println(reader + " read:" + Thread.currentThread().toString() + " : " + this.readWriteLockOperator.read());
        }
      } catch (Exception e) {
        // TODO: handle exception
      }
    }
  }
}

写任务

package cn.itcast.heima.readwritelock;
//可执行任务
public class WriteTask  extends Thread{
  //logic bean
  private ReadWriteLockLogic readWriteLockOperator;
 
  //作者
  private String writer;
 
  public WriteTask(ReadWriteLockLogic readWriteLockOperator, String writer) {
    this.readWriteLockOperator = readWriteLockOperator;
    this.writer = writer;
  }
 
  private WriteTask(){}

  // 一个很耗时的写任务
  public void run() {
    try {
      while(!isInterrupted()){
        Thread.sleep(100);
        this.readWriteLockOperator.write(this.writer, "hehehhe");
      }
    } catch (Exception e) {
      // TODO: handle exception
    }
  }
}

读写操作的逻辑

package cn.itcast.heima.readwritelock;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

//读写操作的逻辑
public class ReadWriteLockLogic {
  // 初始化一个 ReadWriteLock
  private ReadWriteLock lock = new ReentrantReadWriteLock();
 
  //共享资源
  private List<String> shareResources = new ArrayList<String>(0);
 
  //读
  public String read() {

    // 得到 readLock 并锁定
    Lock readLock = lock.readLock();

    readLock.lock();

    try {
      // 读相对省时，做空循环 大约0.5second
      for(int i=0 ;i<2500000; i++){
        System.out.print("");
      }

      // 做读的工作
      StringBuffer buffer = new StringBuffer();
      for (String shareResource : shareResources) {
        buffer.append(shareResource);
        buffer.append("\t");       
      }

      return buffer.toString();

    } finally {
      readLock.unlock();//一定要保证锁的释放
    }
  }

  //写
  public void write(String writer, String content) {

    // 得到 writeLock 并锁定
    Lock writeLock = lock.writeLock();

    writeLock.lock();

    try {
      System.out.println(writer + " write ===" + Thread.currentThread().toString());
      // 写比较费时，所以做空循环 大约13second
      for(int i=0 ;i<50000000; i++){
        System.out.print("");
        System.out.print("");
      }
     
      // 做写的工作
      int count = shareResources.size();
      for (int i=count; i < count + 1; i++) {
        shareResources.add(content + "_" + i);
      }

    } finally {
      writeLock.unlock();//一定要保证锁的释放
    }
  }
}

测试

package cn.itcast.heima.readwritelock;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ReadWriteLockTest {
  public static void main(String[] args) throws InterruptedException, ExecutionException {

    //1 创建一个具有排程功能的线程池
    ScheduledExecutorService service = Executors.newScheduledThreadPool(5);

    //2 读写锁的logic bean
    ReadWriteLockLogic lockOperator = new ReadWriteLockLogic();

    //3 生成一个可执行任务(该任务执行完毕可以返回结果 或者 抛出异常；而Runnable接口的run方法则不行)
    Runnable writeTask1 = new WriteTask(lockOperator, "作者A");

    //4 延时0秒后每2秒重复执行writeTask1;
    service.scheduleAtFixedRate(writeTask1, 0, 60, TimeUnit.SECONDS);

    //5 创建3个读任务
    Runnable readTask1 = new ReadTask(lockOperator, "读者A");
    Runnable readTask2 = new ReadTask(lockOperator, "读者B");
    Runnable readTask3 = new ReadTask(lockOperator, "读者C");

    //6 延时0秒后每秒执行一次task1;
    service.scheduleAtFixedRate(readTask1, 1, 1, TimeUnit.SECONDS);
    service.scheduleAtFixedRate(readTask2, 2, 1, TimeUnit.SECONDS);
    service.scheduleAtFixedRate(readTask3, 3, 1, TimeUnit.SECONDS);
   
  }
}