java排他锁关键字_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关键字功能更强大。