公司的网站,wap网站模板,wordpress调用单页面跳转,wordpress前台会员【尚硅谷周阳--JUC并发编程】【第十四章--ReentrantLock、ReentrantReadWriteLock、StampedLock讲解】 一、面试题二、简单聊聊ReentrantReadWriteLock1、是什么?1.1、读写锁说明1.2、演变1.3、读写锁意义和特点 2、特点2.1、优点2.2、code演示2.3、结论2.4、从写锁-读锁读锁ReentrantReadWriteLock锁降级2.4.1、《Java并发编程的艺术》中关于锁降级的说明2.4.2、读写锁降级演示2.4.3、写锁和读锁是互斥的 2.5、读写锁之读写规矩为什么要锁降级 三、StampedLock1、是什么2、锁饥饿问题2.1、什么是锁饥饿问题2.2、如何解决饥饿问题2.3、StampedLock乐观读锁 3、StampedLock的特点4、乐观读模式案例4.1、StampedLock可用作读写锁4.2、StampedLock支持读的过程中允许写锁的介入 5、StampedLock的缺点 一、面试题
你知道Java里面有那些锁你说你用过读写锁锁饥饿问题是什么有没有比读写锁更快的锁StampedLock知道吗(邮戳锁/票据锁)ReentrantReadWriteLock有锁降级机制你知道吗
二、简单聊聊ReentrantReadWriteLock
1、是什么?
1.1、读写锁说明
ReentrantReadWriteLock读写锁定义为一个资源能够被读个线程访问或者被一个写线程访问但是不能同时存在读写线程。一体两面读写互斥读读共享(写的时候不可以读读的时候不能写)
1.2、演变
无锁无序-加锁-读写锁演变复习 无锁资源访问不安全ReentrantLock串行锁不管是读还是写每次都是一个线程ReadWriteLock(实现类ReentrantReadWriteLock)读写互斥读读可以共享多线程并发可以访问大面积可以容许多个线程来读取。适用于读多写少的情况但是容易造成写锁饥饿问题。需要注意锁降级。
1.3、读写锁意义和特点
它只允许读读共存而读写和写写依然是互斥的大多实际场景是**“读/读”线程间并不存在互斥关系**只有“读/写”线程或“写/写”线程间的操作需要互斥的。因此引入ReentrantReadWriteLock。一个ReentrantReadWriteLock同时只能存在一个写锁但是可以存在多个读锁但不能同时存在写锁和读锁。也即一个资源可以被多个读操作访问或一个写操作访问但两者不能同时进行。只有在读多写少情景之下读写锁才具有较高的性能体现。
2、特点
2.1、优点
可重入读写兼顾
2.2、code演示
使用ReentrantLock一次只有一个线程执行
class MyResource {// 资源类模拟一个简单的缓存MapString, String map new HashMap();// ReentrantLock 等价于 synchronizedReentrantLock lock new ReentrantLock();public void write(String key, String value) {lock.lock();try {System.out.println(Thread.currentThread().getName() \t 正在写入);map.put(key, value);// 暂停几秒try {TimeUnit.MILLISECONDS.sleep(500);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println(Thread.currentThread().getName() \t 完成写入);} finally {lock.unlock();}}public void read(String key) {lock.lock();try {System.out.println(Thread.currentThread().getName() \t 正在读取);String result map.get(key);// 暂停几秒try {TimeUnit.MILLISECONDS.sleep(200);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println(Thread.currentThread().getName() \t 完成读取 \t result);} finally {lock.unlock();}}
}public class ReentrantReadWriteLockDemo {public static void main(String[] args) {MyResource myResource new MyResource();for (int i 0; i 10; i) {int finalI i;new Thread(() - {myResource.write(finalI , finalI );}, String.valueOf(i)).start();}for (int i 0; i 10; i) {int finalI i;new Thread(() - {myResource.read(finalI );}, String.valueOf(i)).start();}}}使用读写锁ReentrantReadWriteLock
class MyResource {// 资源类模拟一个简单的缓存MapString, String map new HashMap();// ReentrantReadWriteLock一体两面读写互斥读读共享ReadWriteLock rwLock new ReentrantReadWriteLock();public void write(String key, String value) {rwLock.writeLock().lock();try {System.out.println(Thread.currentThread().getName() \t 正在写入);map.put(key, value);// 暂停几秒try {TimeUnit.MILLISECONDS.sleep(500);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println(Thread.currentThread().getName() \t 完成写入);} finally {rwLock.writeLock().unlock();}}public void read(String key) {rwLock.readLock().lock();try {System.out.println(Thread.currentThread().getName() \t 正在读取);String result map.get(key);// 暂停几秒try {TimeUnit.MILLISECONDS.sleep(200);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println(Thread.currentThread().getName() \t 完成读取 \t result);} finally {1rwLock.readLock().unlock();}}
}public class ReentrantReadWriteLockDemo {public static void main(String[] args) {MyResource myResource new MyResource();for (int i 0; i 10; i) {int finalI i;new Thread(() - {myResource.write(finalI , finalI );}, String.valueOf(i)).start();}for (int i 0; i 10; i) {int finalI i;new Thread(() - {myResource.read(finalI );}, String.valueOf(i)).start();}}} 读未完成时写无法获得锁
class MyResource {// 资源类模拟一个简单的缓存MapString, String map new HashMap();// ReentrantLock 等价于 synchronizedReentrantLock lock new ReentrantLock();// ReentrantReadWriteLock一体两面读写互斥读读共享ReadWriteLock rwLock new ReentrantReadWriteLock();public void write(String key, String value) {rwLock.writeLock().lock();try {System.out.println(Thread.currentThread().getName() \t 正在写入);map.put(key, value);// 暂停几秒try {TimeUnit.MILLISECONDS.sleep(500);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println(Thread.currentThread().getName() \t 完成写入);} finally {rwLock.writeLock().unlock();}}public void read(String key) {rwLock.readLock().lock();try {System.out.println(Thread.currentThread().getName() \t 正在读取);String result map.get(key);// 暂停几秒try {TimeUnit.MILLISECONDS.sleep(2000);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println(Thread.currentThread().getName() \t 完成读取 \t result);} finally {rwLock.readLock().unlock();}}
}public class ReentrantReadWriteLockDemo {public static void main(String[] args) {MyResource myResource new MyResource();for (int i 0; i 10; i) {int finalI i;new Thread(() - {myResource.write(finalI , finalI );}, String.valueOf(i)).start();}for (int i 0; i 10; i) {int finalI i;new Thread(() - {myResource.read(finalI );}, String.valueOf(i)).start();}for (int i 0; i 3; i) {int finalI i;new Thread(() - {myResource.write(finalI , finalI );}, 新写锁 String.valueOf(i)).start();}}}2.3、结论
一体两面读写互斥读读共享读没有完成时候其他线程写锁无法获得
2.4、从写锁-读锁ReentrantReadWriteLock锁降级
2.4.1、《Java并发编程的艺术》中关于锁降级的说明 2.4.2、读写锁降级演示
可以降级 锁降级是为了让当前线程感知到数据的变化目的是保证数据可见性 案例
如果一个线程占有了写锁在不释放写锁的情况下它还能占有读锁即写锁降级为读锁
/*** 锁降级遵循获取写锁-在获取读锁-再释放写锁的次序写锁能够降级成为读锁。** 如果一个线程占有了写锁在不释放写锁的情况下它还能占有读锁即写锁降级为读锁** 读没有完成时候写锁无法获得锁必须要等着读锁读完之后才有机会** author 匍匐丶前进* since 2024/3/29 16:56**/
public class LockDownGradingDemo {public static void main(String[] args) {ReentrantReadWriteLock readWriteLock new ReentrantReadWriteLock();ReentrantReadWriteLock.ReadLock readLock readWriteLock.readLock();ReentrantReadWriteLock.WriteLock writeLock readWriteLock.writeLock();// 同一个线程writeLock.lock();System.out.println(------写入);readLock.lock();System.out.println(------读取);writeLock.unlock();System.out.println(------写入完成);readLock.unlock();System.out.println(------读取完成);}
} 读没有完成时候写锁无法获得锁必须要等着读锁读完之后才有机会读锁无法升级为写锁
/*** 锁降级遵循获取写锁-在获取读锁-再释放写锁的次序写锁能够降级成为读锁。** 如果一个线程占有了写锁在不释放写锁的情况下它还能占有读锁即写锁降级为读锁** 读没有完成时候写锁无法获得锁必须要等着读锁读完之后才有机会** author 匍匐丶前进* since 2024/3/29 16:56**/
public class LockDownGradingDemo {public static void main(String[] args) {ReentrantReadWriteLock readWriteLock new ReentrantReadWriteLock();ReentrantReadWriteLock.ReadLock readLock readWriteLock.readLock();ReentrantReadWriteLock.WriteLock writeLock readWriteLock.writeLock();// 同一个线程readLock.lock();System.out.println(------读取);writeLock.lock();System.out.println(------写入);writeLock.unlock();System.out.println(------写入完成);readLock.unlock();System.out.println(------读取完成);}
} 不可以升级
2.4.3、写锁和读锁是互斥的 2.5、读写锁之读写规矩为什么要锁降级
Oracle公司ReentrantReadWriteLock源码总结 锁降级 下面的示例代码摘自ReentrantReadWriteLock源码中 ReentrantReadWriteLock支持锁降级遵循按照获取写锁获取读锁再释放写锁的次序写锁能够降级为读锁不支持锁升级
class CachedData {// 数据Object data;// 默认falsevolatile boolean cacheValid;final ReentrantReadWriteLock rwl new ReentrantReadWriteLock();void processCachedData() {rwl.readLock().lock();// 查看缓存是否有数据if (!cacheValid) {// 在写锁之前必须要先释放读锁rwl.readLock().unlock();rwl.writeLock().lock();try {// 重新校验状态因为其他写线程可能在这之前修改了状态(类似双端检索)if (!cacheValid) {// 写操作data ...cacheValid true;}// 锁降级--在释放写锁之前占用读锁(理解为当前线程写完之后需要获取当前最新data进行后续操作不希望别其他线程在修改data)rwl.readLock().lock();} finally {// 释放写锁继续持有读锁rwl.writeLock().unlock();}}try {// 完成读后操作use(data);} finally {// 释放读锁rwl.readLock().unlock();}}
}代码中声明了一个Volatile类型的cacheValid变量保证其可见性。首先获取读锁如果cache不可用则释放读锁。获取写锁在更改数据之前再检查一次cacheValid的值然后修改数据将cacheValid置为true然后在释放写锁前立刻抢夺获取读锁此时cache中数据可用处理cache中数据最后释放读锁。这个过程就是一个完整的锁降级的过程目的是保证数据可见性。总结一句话同一个线程自己持有写锁时再去拿读锁其本质相当于重入如果未被锁降级的步骤即如果当前的线程C在修改完cache中的数据后没有获取读锁而是直接释放了写锁那么假设此时另一个线程D获取了写锁并修改了数据那么C线程无法感知到数据已被修改则数据出现错误。
三、StampedLock
面试题有没有比读写锁更快地锁
1、是什么
StampedLock是JDK1.8中新增的一个读写锁也是对JDK1.5中的读写锁ReentrantReadWriteLock的优化邮戳锁又叫票据锁stamp(邮戳long类型) 代表了锁的状态。当stamp返回零时表示线程获取锁失败。并且当释放锁或者转换锁的时候都要传入最初获取的stamp值
2、锁饥饿问题
2.1、什么是锁饥饿问题
ReentrantReadWriteLock实现了读写分离但是一旦读操作比较多的时候想要获取写锁就变得比较困难了假如当前1000个线程999个读1个写有可能999个读取线程长时间抢到了锁那1个写线程就悲剧了因为当前有可能会一直存在读锁而无法获得写锁根本没有机会。
2.2、如何解决饥饿问题
使用“公平”策略可以一定程度上缓解这个问题
ReentrantReadWriteLock readWriteLock new ReentrantReadWriteLock(true);但是“公平”策略是以牺牲系统吞吐量为代价的。
2.3、StampedLock乐观读锁
ReentrantReadWriteLock,允许多个线程同时读但是只允许一个线程写在线程获取到写锁的时候其他写操作和读操作都会处于阻塞状态。读锁和写锁也是互斥的所以在读的时候是不允许写的。读写锁比传统的synchronized速度要快很多原因就是在于ReentrantReadWriteLock支持并发读读读可以共享。ReentrantReadWriteLock的读锁被占用的时候其他线程尝试获取写锁的时候会被阻塞。但是StampedLock采用乐观锁获取锁后其他线程尝试获取写锁时不会被阻塞这其实是对读锁的优化所以在获取乐观锁后还需要对结果进行校验。一句话对短的只读代码段使用乐观模式通常可以减少争用并提高吞吐量。
3、StampedLock的特点
所有获取锁的方法都返回一个邮戳(Stamp)Stamp为零表示获取失败其余都表示成功所有释放锁的方法都需要一个邮戳(Stamp)这个Stamp必须是和成功获取锁时得到的Stamp一致StampedLock是不可重入的危险(如果一个线程已经持有了写锁再去获取写锁的话就会造成死锁)StampedLock有三种访问模式 Reading(读模式悲观)功能和ReentrantReadWriteLock的读锁类似Writing(写模式)功能呢过和ReentrantReadWriteLock的写锁类似Optimistic reading(乐观读模式)无锁机制类似于数据库中的乐观锁支持读写并发很乐观认为读取时没人修改假如被修改再实现升级为悲观锁模式。
4、乐观读模式案例
读的过程中也允许获取写锁介入
4.1、StampedLock可用作读写锁
public class StampedLockDemo {// StampedLock ReentrantReadWriteLock 读的过程中允许写锁的介入static int number 37;static StampedLock stampedLock new StampedLock();public void write() {// 返回一个流水戳记long stamp stampedLock.writeLock();System.out.println(Thread.currentThread().getName() \t 写线程准备修改);try {number number 13;} finally {stampedLock.unlockWrite(stamp);}System.out.println(Thread.currentThread().getName() \t 写线程结束修改);}// 悲观读读没有完成时候写锁无法获得锁public void read() {long stamp stampedLock.readLock();System.out.println(Thread.currentThread().getName() \t come in readLock code lock,4 seconds continue...);for (int i 0; i 4; i) {try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println(Thread.currentThread().getName() \t 正在读取中......);}try {int result number;System.out.println(Thread.currentThread().getName() \t 获得成员变量值result result);System.out.println(写线程没有修改成功读锁时候写锁无法介入传统的读写互斥);} finally {stampedLock.unlockRead(stamp);}}public static void main(String[] args) {StampedLockDemo resource new StampedLockDemo();new Thread(() - {resource.read();}, readThread).start();// 暂停几秒try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {throw new RuntimeException(e);}new Thread(() - {System.out.println(Thread.currentThread().getName() \t ------come in);resource.write();}, writeThread).start();try {TimeUnit.SECONDS.sleep(4);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println(Thread.currentThread().getName() \t number: number);}
}4.2、StampedLock支持读的过程中允许写锁的介入
public class StampedLockDemo {// StampedLock ReentrantReadWriteLock 读的过程中允许写锁的介入static int number 37;static StampedLock stampedLock new StampedLock();public void write() {// 返回一个流水戳记long stamp stampedLock.writeLock();System.out.println(Thread.currentThread().getName() \t 写线程准备修改);try {number number 13;} finally {stampedLock.unlockWrite(stamp);}System.out.println(Thread.currentThread().getName() \t 写线程结束修改);}// 乐观读读的过程中允许获取写锁介入public void tryOptimisticRead() {long stamp stampedLock.tryOptimisticRead();int result number;// 故意间隔四秒很乐观认为读取中没有其他线程修改过number的值System.out.println(4秒前stampedLock.validate(stamp)方法值(true无修改false有修改) \t stampedLock.validate(stamp));for (int i 0; i 4; i) {try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println(Thread.currentThread().getName() \t 正在读取...... i 秒后stampedLock.validate(stamp)方法值(true无修改false有修改) \t stampedLock.validate(stamp));}if (!stampedLock.validate(stamp)) {System.out.println(有修改过------有写操作);stamp stampedLock.readLock();try {System.out.println(从乐观读 升级为 悲观读);result number;System.out.println(重新悲观读后result result);} finally {stampedLock.unlockRead(stamp);}}System.out.println(Thread.currentThread().getName() \t finally vlaue result);}public static void main(String[] args) {StampedLockDemo resource new StampedLockDemo();new Thread(() - {resource.tryOptimisticRead();}, readThread).start();try {TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) {throw new RuntimeException(e);}new Thread(() - {System.out.println(Thread.currentThread().getName() \t ------come in);resource.write();}, writeLock).start();}
}5、StampedLock的缺点
StampedLock不支持重入没有Re开头StampedLock的悲观读锁和写锁都不支持条件变量(Condition)这个也需要注意使用StampedLock一定不要调用中断操作即不要调用interrupt()方法
