读写锁操作
来源:互联网 发布:电商运营数据分析表格 编辑:程序博客网 时间:2024/06/06 02:10
说到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); }}
- 读写锁操作(ReaderWriterLockSlim)
- 读写锁操作
- 读写操作
- mongodb各操作的读写锁
- 文件读写操作
- 另一个文件读写操作
- 读写模版的操作
- xml的读写操作
- [C++]文件读写操作
- 读写文件操作
- xml文件操作( 读写)
- 文件的读写操作
- 文件的读写操作
- nandflash的读写操作
- Nand读写操作
- C#操作注册表(读写)
- Nand读写操作
- WINCE 读写注册表操作
- const2buffer
- OpenMP编程入门之一
- hdu3478 Catch
- 8086 系统结构图
- MFC中操作office软件(doc和excel)
- 读写锁操作
- 基数排序的java实现
- 求n!的最高位数字
- linux2 6 35内核视频网络移植
- CPU流水线详解
- SVN功能详解
- Linux磁盘分区命名方案
- Recipe 2.16. Walking Directory Trees
- (转载)oracle开发规范