乐观锁、悲观锁及死锁

乐观锁、悲观锁

1.概念

悲观锁(悲观锁定)：具有强烈的独占和排他特性。在整个执行过程中，将处于锁定状态。悲观锁在持有数据的时候总会把资源或者数据锁住，这样其他线程想要请求这个资源的时候就会阻塞，直到等到悲观锁把资源释放为止. （例如：Synchronized和ReetrantLock）
乐观锁(乐观锁定)：乐观锁机制采取了更加宽松的加锁机制。乐观锁在读取时不会上锁，但是乐观锁在进行写入操作的时候会判断当前数据是否被修改过。

（例如：JAVA中的Stamp锁定和原子整型）

2.锁的使用----读写

ReentranLock

保证了只有一个线程可以执行临界区代码

问题：任何时刻，只允许一个线程执行，不是读线程，就是写线程

👏改进一下：允许多个线程同时读，但只有一个线程在写，其他线程就必须等待

ReadWriteLock

只允许一个线程写入(其他线程既不能写入，也不能读取)
没有写入时，多个线程允许同时读(提高性能)

 public class ReadWriteLockTest {private final ReadWriteLock lock = new ReentrantReadWriteLock();private final Lock readLock = lock.readLock();private final Lock writeLock = lock.writeLock();private int[] counts = new int[10];public void inc(int index){writeLock.lock();try {counts[index]+=1;} finally {writeLock.unlock();}}public int[] get(){readLock.lock();try {return Arrays.copyOf(counts,counts.length);} finally {readLock.unlock();}}}

在读取时，多个线程可以同时获取读锁，大大提高了并发读的执行效率。

问题：如果有线程正在读，写线程需要等待读线程释放锁后才能获取写锁，即读的过程中不允许写.

👏改进一下：读的过程中也允许获取写锁写入！

StampedLock

读的数据就可能不一致，需要一点额外的代码来判断读的过程中是否有写入。所以，这种读锁是一种乐观锁

public class Test2 {private final StampedLock stampedLock = new StampedLock();private double x;private double y;public void move(double deltaX,double deltaY){long stamp = stampedLock.writeLock();try {x += deltaX;y += deltaY;} finally {stampedLock.unlock(stamp);}}public double distanceFromOrigin(){//假设下面两行代码不是原子操作//假设x,y =(100,200)//获取读锁(乐观锁)long stamp = stampedLock.tryOptimisticRead();double currentX =x;//此处已读取到x=100，如果没有写入,读取是正确的(100,200)double currentY =y;//此处已读取到y，如果没有写入,读取是正确的(100,200)//如果有写入，读取是错误的(100,400)//检查乐观锁的版本号值(stamp)是否一致if(!stampedLock.validate(stamp)){//获取读锁(悲观锁)stamp = stampedLock.tryReadLock();//重新获取try {currentY=y;currentX=x;} finally {stampedLock.unlock(stamp);}}//计算return Math.sqrt(currentX*currentX+currentY*currentY);}}

和ReadWriteLock相比，写入的加锁是完全一样的，不同的是读取

步骤：

1.通过Try OptimisTicRead()获取一个乐观读锁，并返回版本号。

2.进行读取，读取完成后，我们通过验证validate()去验证版本号，如果在读取过程中没有写入，版本号不变，验证成功，继续后续操作.如果在读取过程中有写入，版本号会发生变化，验证将失败。

3.当验证失败时，再通过ReadLock()获取悲观锁再次读取。（由于写入的概率不高，程序在绝大部分情况下可以通过乐观读锁获取数据，极少数情况下使用悲观读锁获取数据）。

所以，StampeLock把读锁细分为乐观读和悲观读，能进一步提升并发效率。

但这也是有代价的:

一是代码更加复杂。

二是Stamp锁定是不可重入锁，不能在一个线程中反复获取同一个锁。

死锁

1.概念

多个线程在运行中，都需要获取对方线程所持有的锁(资源)，导致处于长期无限等待的状态。

死锁发生后，只能通过强制结束JVM进程来解决死锁。

public class Test3 {public static void main(String[] args) {DeadLock deadLock = new DeadLock();Thread t1 = new Thread(() -> {try {deadLock.add();} catch (InterruptedException e) {e.printStackTrace();}});Thread t2 = new Thread(() -> {deadLock.dec();});t1.start();t2.start();}}class DeadLock{//两把锁private static Object lockA = new Object();private static  Object lockB = new Object();public void add() throws InterruptedException {synchronized (lockA){//获得lockA的锁Thread.sleep(100);//线程休眠synchronized (lockB){System.out.println("执行add()");}//释放lockB的锁}//释放lockA的锁}public void dec(){synchronized (lockB){//获得lockB的锁synchronized (lockA){//获得lockA的锁System.out.println("执行dec()");}//释放lockA的锁}//释放lockB的锁}}