教学网站建设目的,惠州电商网站建设,十大装修公司排名哪家最好,网站排名外包文章目录1、可重入锁#xff08;递归锁#xff09;2、读写锁2.1、读写分离2.2、从写锁到读锁#xff0c;ReentrantReadWriteLock可以降级2.3、写锁和读锁是互斥的3、邮戳锁StampedLock3.1、是什么3.2、锁饥饿3.3、如何缓解锁饥饿问题呢3.3.1、使用“公平”策略3.3.2、Stampe…
文章目录1、可重入锁递归锁2、读写锁2.1、读写分离2.2、从写锁到读锁ReentrantReadWriteLock可以降级2.3、写锁和读锁是互斥的3、邮戳锁StampedLock3.1、是什么3.2、锁饥饿3.3、如何缓解锁饥饿问题呢3.3.1、使用“公平”策略3.3.2、StampedLock类的乐观锁3.4、StampedLock的特点3.5、StampedLock的三种访问模式3.6、StampedLock的缺点1、可重入锁递归锁
可重入锁是一种技术 任意线程在获取到锁之后能够再次获取该锁而不会被锁所阻塞。
可重入锁的原理 通过组合自定义同步器来实现锁的获取与释放。
再次获取锁识别获取锁的线程是否为当前占据锁的线程如果是则再次成功获取。获取锁后进行计数自增释放锁释放锁时进行计数自减。
Java中的可重入锁 ReentrantLock、synchronized修饰的方法或代码段。
可重入锁的作用 避免死锁。 面试题1 可重入锁如果加了两把但是只释放了一把会出现什么问题 答程序卡死线程不能出来也就是说我们申请了几把锁就需要释放几把锁。 面试题2 如果只加了一把锁释放两次会出现什么问题 答会报错java.lang.IllegalMonitorStateException 2、读写锁
2.1、读写分离
读写锁定义为一个资源能够被多个读线程访问或者被一个写线程访问但是不能同时存在读写线程 读写分离、可重入
读写锁 通过ReentrantReadWriteLock类来实现 ,只允许读读共存读写互斥
为了提高性能Java 提供了读写锁在读的地方使用读锁在写的地方使用写锁灵活控制如果没有写锁的情况下读是无阻塞的在一定程度上提高了程序的执行效率。 读写锁分为读锁 和写锁多个读锁不互斥读锁与写锁互斥这是由 jvm 自己控制的。
读锁 允许多个线程获取读锁同时访问同一个资源。
写锁 只允许一个线程获取写锁不允许同时访问同一个资源。 举个栗子加深理解
class MyResource
{MapString,String map new HashMap();//ReentrantLock 等价于 synchronized//Lock lock new ReentrantLock();//ReentrantReadWriteLock 一体两面读写互斥读读共享ReentrantReadWriteLock 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) { e.printStackTrace(); }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);//后续开启注释修改为2000演示一体两面读写互斥读读共享读没有完成时候写锁无法获得//try { TimeUnit.MILLISECONDS.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); }System.out.println(Thread.currentThread().getName()\t---完成读取resultresult);}finally {rwLock.readLock().unlock();}}
}public class ReentrantReadWriteLockDemo
{public static void main(String[] args){MyResource myResource new MyResource();for (int i 1; i 10; i) {int finalI i;new Thread(() - {myResource.write(finalI , finalI );},String.valueOf(i)).start();}for (int i 1; i 10; i) {int finalI i;new Thread(() - {myResource.read(finalI );},String.valueOf(i)).start();}//暂停几秒钟线程try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }//读全部over才可以继续写for (int i 1; i 3; i) {int finalI i;new Thread(() - {myResource.write(finalI , finalI );},newWriteThreadString.valueOf(i)).start();}}/*** 运行结果:* 3 ---正在写入* 3 ---完成写入* 4 ---正在写入* 4 ---完成写入* 1 ---正在写入* 1 ---完成写入* 2 ---正在写入* 2 ---完成写入* 5 ---正在写入* 5 ---完成写入* 6 ---正在写入* 6 ---完成写入* 7 ---正在写入* 7 ---完成写入* 8 ---正在写入* 8 ---完成写入* 9 ---正在写入* 9 ---完成写入* 10 ---正在写入* 10 ---完成写入* 1 ---正在读取* 1 ---完成读取result1* 2 ---正在读取* 3 ---正在读取* 5 ---正在读取* 5 ---完成读取result5* 2 ---完成读取result2* 10 ---正在读取* 10 ---完成读取result10* 4 ---正在读取* 8 ---正在读取* 8 ---完成读取result8* 9 ---正在读取* 9 ---完成读取result9* 7 ---正在读取* 7 ---完成读取result7* 6 ---正在读取* 6 ---完成读取result6* 3 ---完成读取result3* 4 ---完成读取result4* newWriteThread3 ---正在写入* newWriteThread3 ---完成写入* newWriteThread2 ---正在写入* newWriteThread2 ---完成写入* newWriteThread1 ---正在写入* newWriteThread1 ---完成写入** Process finished with exit code 0*/
}2.2、从写锁到读锁ReentrantReadWriteLock可以降级
锁降级遵循获取写锁、获取读锁再释放写锁写锁能够降级为读锁
一句话将写锁降级为读锁
如果一个线程占有了写锁在不释放写锁的情况下它还能占有读锁即写锁降级为读锁。 锁降级是为了让当前线程感知到数据的变化目的是保证数据可见性
举个栗子
/*** 锁降级遵循获取写锁→再获取读锁→再释放写锁的次序写锁能够降级成为读锁。** 如果一个线程占有了写锁在不释放写锁的情况下它还能占有读锁即写锁降级为读锁。*/
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();}/*** 运行结果:* -------正在写入* -------正在读取** Process finished with exit code 0*/
}线程获取读锁是不能直接升级为写入锁的也就是说可以写锁降级为读锁不可逆 在ReentrantReadWriteLock中当读锁被使用时如果有线程尝试获取写锁该写线程会被阻塞
所以需要释放所有读锁才可获取写锁
2.3、写锁和读锁是互斥的
这里的互斥是指线程间的互斥当前线程可以获取到写锁又获取到读锁但是获取到了读锁不能继续获取写锁这是因为读写锁要保持写操作的可见性。
因为如果允许读锁在被获取的情况下对写锁的获取那么正在运行的其他读线程无法感知到当前写线程的操作,可能会出现脏读。
因此分析读写锁ReentrantReadWriteLock会发现它有个潜在的问题
如果有线程正在读写线程需要等待读线程释放锁后才能获取写锁
即ReadWriteLock读的过程中不允许写只有等待线程都释放了读锁当前线程才能获取写锁
也就是写入必须等待这是一种悲观的读锁o(╥﹏╥)o人家还在读着那你先别去写省的数据乱 有没有比读写锁更快的锁 3、邮戳锁StampedLock
无锁、独占锁、读写锁、邮戳锁
3.1、是什么
StampedLock是JDK1.8中新增的一个读写锁是对JDK1.5中的读写锁ReentrantReadWriteLock的优化
stamp 戳记 代表了锁的状态当stamp返回 0 时 表示线程获取锁失败当释放锁或者转换锁的时候都要传入最初获取的 stamp 值
3.2、锁饥饿
ReentrantReadWriteLock实现了读写分离但是一旦读操作比较多的时候想要获取写锁就变得比较困难了
假如当前1000个线程999个读1个写有可能999个读取线程长时间抢到了锁那1个写线程就悲剧了
因为当前有可能会一直存在读锁而无法获得写锁根本没机会写o(╥﹏╥)o
3.3、如何缓解锁饥饿问题呢
3.3.1、使用“公平”策略
使用“公平”策略可以一定程度上缓解锁饥饿问题但是会牺牲系统吞吐量为代价 new ReentrantReadWriteLock(true) 3.3.2、StampedLock类的乐观锁
ReentrantReadWriteLock
允许多个线程同时读但是只允许一个线程写在线程获取到写锁的时候其他写操作和读操作都会处于阻塞状态
读锁和写锁也是互斥的所以在读的时候是不允许写的读写锁比传统的synchronized速度要快很多
原因就是在于ReentrantReadWriteLock支持读并发
StampedLock横空出世
ReentrantReadWriteLock的读锁被占用的时候其他线程尝试获取写锁的时候会被阻塞。
但是StampedLock采取乐观获取锁后其他线程尝试获取写锁时不会被阻塞这其实是对读锁的优化
所以在获取乐观读锁后还需要对结果进行校验。
3.4、StampedLock的特点
所有获取锁的方法都返回一个邮戳Stamp,Stamp 为0 表示失败其余都表示成功所有释放锁的方法都需要一个邮戳Stamp,这个Stamp必须和成功获取锁时得到的Stamp 一致StampedLock是不可重入的如果一个线程已经持有了写锁再去获取写锁的话就会造成死锁
3.5、StampedLock的三种访问模式
Reading(读模式)功能和ReentrantReadWriteLock的读锁类似Writing(写模式)功能和ReentrantReadWriteLock的写锁类似Optimistic reading 乐观读模式无锁机制类似于数据库中的乐观锁支持读写并发很乐观的认为读操作时没有人来修改假如被修改再升级为悲观锁模式
乐观读模式小栗子读的过程中允许写锁介入
public class StampedLockDemo
{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;}catch (Exception e){e.printStackTrace();}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 block,4 seconds continue...);//暂停几秒钟线程for (int i 0; i 4 ; i) {try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }System.out.println(Thread.currentThread().getName()\t 正在读取中......);}try{int result number;System.out.println(Thread.currentThread().getName()\t 获得成员变量值result result);System.out.println(写线程没有修改值因为 stampedLock.readLock()读的时候不可以写读写互斥);}catch (Exception e){e.printStackTrace();}finally {stampedLock.unlockRead(stamp);}System.out.println(Thread.currentThread().getName()\t finally value: number);}//乐观读public void tryOptimisticRead(){long stamp stampedLock.tryOptimisticRead();int result number;//间隔4秒钟我们很乐观的认为没有其他线程修改过number值实际靠判断。System.out.println(4秒前stampedLock.validate值(true无修改false有修改)\tstampedLock.validate(stamp));for (int i 1; i 4 ; i) {try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }System.out.println(Thread.currentThread().getName()\t 正在读取中......i秒后stampedLock.validate值(true无修改false有修改)\tstampedLock.validate(stamp));}if(!stampedLock.validate(stamp)) {System.out.println(有人动过--------存在写操作);stamp stampedLock.readLock();try {System.out.println(从乐观读 升级为 悲观读);result number;System.out.println(重新悲观读锁通过获取到的成员变量值result result);}catch (Exception e){e.printStackTrace();}finally {stampedLock.unlockRead(stamp);}}System.out.println(Thread.currentThread().getName()\t finally value: result);}public static void main(String[] args){StampedLockDemo resource new StampedLockDemo();new Thread(() - {//resource.read();resource.tryOptimisticRead();},readThread).start();// 2秒钟时乐观读失败6秒钟乐观读取成功resource.tryOptimisticRead();修改切换演示try { TimeUnit.SECONDS.sleep(6); } catch (InterruptedException e) { e.printStackTrace(); }new Thread(() - {resource.write();},writeThread).start();}/*** 运行过程:* 悲观读情况:* readThread come in readlock block,4 seconds continue...* readThread 正在读取中......* readThread 正在读取中......* readThread 正在读取中......* readThread 正在读取中......* readThread 获得成员变量值result37* 写线程没有修改值因为 stampedLock.readLock()读的时候不可以写读写互斥* writeThread 写线程准备修改* writeThread 写线程结束修改** 进程已结束,退出代码0* --------------------------------------------------------------------* 乐观读情况:* 4秒前stampedLock.validate值(true无修改false有修改) true* readThread 正在读取中......1秒后stampedLock.validate值(true无修改false有修改) true* readThread 正在读取中......2秒后stampedLock.validate值(true无修改false有修改) true* readThread 正在读取中......3秒后stampedLock.validate值(true无修改false有修改) true* readThread 正在读取中......4秒后stampedLock.validate值(true无修改false有修改) true* readThread finally value: 37* main最终值37* writeThread 写线程准备修改* writeThread 写线程结束修改** 进程已结束,退出代码0*/
}3.6、StampedLock的缺点
StampedLock不支持重入没有Re开头
StampedLock的悲观读锁和写锁都不支持条件变量Condition
使用StampedLock 一定不要调用中断操作即不要调用 interrupt()方法
如果需要支持中断功能一定使用可中断的悲观读锁readLockInterruptibly()和写锁writeLockInterruptibly()
