Java并发编程:Lock的使用,可重入锁、读写锁、排他锁、乐观锁、悲观锁等

概述

Lock顾名思义就是锁,也能实现同步的效果,主要学习ReentrantLock(可重入锁)、ReentrantReadWriteLock(可重入读写锁)

ReentrantLock

在Java多线程中， 可以使用synchronized关键字来实现线程之间同步互斥， Reentrant Lock类也能达到同样的效果， 并且在扩展功能上也更加强大，比如具有嗅探锁定、多路分支通知等功能，而且在使用上也比synchronized更加的灵活。

Condition实现等待/通知

关键字synchronized与wait() 和notify() /notifyAll() 方法相结合可以实现等待/通知模式，
类ReentrantLock可以通过Condition对象实现同样的功能。使用Condition类有更好的灵活性，比如可以实现多路通知功能， 也就是在一个Lock对象里面可以创建多个Condition(即对象监视器) 实例， 线程对象可以注册在指定的Condition中， 从而可以有选
择性地进行线程通知，在调度线程上更加灵活。
wait/notify 是随JVM随机选择通知，而ReentrantLock借助Condition可以"选择性"通知

公平锁与非公平锁概念

公平锁:表示线程获取锁的顺序是按线程加锁顺序来的,FIFO先进先出
非公平锁:抢占式获取锁,是随机获取锁

private ReentrantLock lock;
lock = new ReentrantLock (true);//公平锁
lock = new ReentrantLock (false);//非公平锁

ReentrantReadWriteLock

ReentrantReadWriteLock类(读写锁)， 使用它可以加快运行效率， 在某些不需要操作实例
变量的方法中， 完全可以使用读写锁Reentrant ReadWrite Lock来提升该方法的代
码运行速度。
读写锁表示也有两个锁，一个是读操作相关的锁，也称为共享锁；另一个是写操作
相关的锁，也叫排他锁。也就是多个读锁之间不互斥，读锁与写锁互斥，写锁与写
锁互斥。在没有线程Thread进行写入操作时， 进行读取操作的多个Thread都可以
获取读锁， 而进行写入操作的Thread只有在获取写锁后才能进行写入操作。即多个
Thread可以同时进行读取操作， 但是同一时刻只允许一个Thread进行写入操作。
即:读读共享，读写互斥，写读互斥，写写互斥

Java 8的StampedLock

Java 8 引入了一个新的读写锁叫StampedLock. 不仅这个锁更快，而且它提供强大的乐观锁API，这意味着你能以一个较低的代价获得一个读锁, 在这段时间希望没有写操作发生，当这段时间完成后，你可以查询一下锁，看是否在刚才这段时间是否有写操作发生？然后你可以决定是否需要再试一次 或升级锁或放弃。

StampedLock要比ReentrantReadWriteLock更加廉价，也就是开销比较小。
StampedLock控制锁有三种模式，一个StampedLock状态是由版本和模式两个部分组成，锁获取方法返回一个数字作为票据stamp，它用相应的锁状态表示并控制访问，数字0表示没有写锁被授权访问。在读锁上分为悲观锁和乐观锁。
StampedLock使用

public class BankAccountWithStampedLock {
    private final StampedLock lock = new StampedLock();
    private double balance;
    public void deposit(double amount) {
        long stamp = lock.writeLock();
        try {
            balance = balance + amount;
        } finally {
            lock.unlockWrite(stamp);
        }
    }

    public double getBalance() {
        long stamp = lock.readLock();
        try {
            return balance;
        } finally {
            lock.unlockRead(stamp);
        }
    }
}

public class MyPoint {

    private double x, y;
    private final StampedLock sl = new StampedLock();
    // method is modifying x and y, needs exclusive lock stampLock中的排他锁实现:
    public void move(double deltaX, double deltaY) {

        long stamp = sl.writeLock();
        try {
            x += deltaX;
            y += deltaY;
        } finally {

            sl.unlockWrite(stamp);
        }
    }

// 悲观锁实现,并实现读锁转写锁
public void moveIfAt(double oldX, double oldY, double newX, double newY) {

        long stamp = sl.readLock(); //获得一个读悲观锁
        try {

            while (x == oldX && y == oldY) {  //循环，检查当前状态是否符合
                long writeStamp = sl.tryConvertToWriteLock(stamp);//将读锁转为写锁
                if (writeStamp != 0L) {//这是确认转为写锁是否成功

                    stamp = writeStamp; //如果成功 替换票据
                    x = newX; y = newY; //进行状态改变
                    break;

                //如果不能成功转换为写锁
                } else { 
                    sl.unlockRead(stamp);//我们显式释放读锁
                    stamp = sl.writeLock(); //显式直接进行写锁 然后再通过循环再试
                }
            }
        } finally {

            sl.unlock(stamp); //释放读锁或写锁
        }
    }
    
 //乐观锁实现
public double distanceFromOrigin() {

        long stamp = sl.tryOptimisticRead(); //获得一个乐观读锁

        double currentX = x, currentY = y; //将两个字段读入本地局部变量

        //检查发出乐观读锁后同时是否有其他写锁发生？
        if (!sl.validate(stamp)) {

            //如果没有，我们再次获得一个读悲观锁
            stamp = sl.readLock();
            try {

                // 将两个字段读入本地局部变量
                currentX = x;
                currentY = y;
            } finally {
                sl.unlockRead(stamp); //释放读锁
            }
        }
        return Math.sqrt(currentX * currentX + currentY * currentY);
    }
}

总结

使用Lock对象可以替换掉synchronized关键字的使用，而且比synchronized关键字功能更强大。