JUC并发编程之线程锁（一）

目录

1.ReentrantLock(互斥锁)

 2.ReentRantReaderWriterLock（互斥读写锁）

3.StampedLock（无障碍锁）

4.Condition（自定义锁）

5.LockSupport

---

问题引出：

        由于传统的线程控制需要用到同步机制Synchronized与 Object类中的wait();notify();函数进行控制，但是这样控制并不容易，所以在JUC中提供了全新的框架，

框架核心接口为：1.Lock();2.ReaderWriteLock（）；

1.ReentrantLock(互斥锁)

ReentrantLock是一种互斥锁，意思是一旦有一个线程获取到锁，那么其他线程就无法运行将会进行等待阻塞。其中又分为公平锁和非公平锁。区别在于获取锁的机制是否公平。并且该锁通过一个FIFO队列管理所有的等待线程。

 以下是ReentrantLock类的常用方法：

方法名	描述
ReentrantLock()	创建一个新的ReentrantLock实例。
ReentrantLock(boolean fair)	创建一个新的ReentrantLock实例，根据参数fair的值决定是否按公平顺序获取锁。
lock()	获取锁，如果锁不可用，则当前线程将被阻塞，直到锁可用。
unlock()	释放锁，使得其他等待锁的线程可以尝试获取锁。
tryLock()	尝试获取锁，如果锁可用则获取锁并返回true，否则立即返回false。
isFair()	判断锁是否是公平锁，如果是公平锁则返回true，否则返回false。
new Condition()	创建一个与该锁关联的Condition对象，用于线程间等待和通知，在调用Condition的await方法时，当前线程会释放锁。

案例：有五个售票员同时售卖8张票

package Example2110;import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;class  Ticeket{private int ticket = 8;
//    创建互斥锁并设置为公平锁，所有线程运行都是等概率的ReentrantLock reentrantLock = new ReentrantLock(true);public  void sale(){while (true){//        开启锁只有一个线程能通过reentrantLock.lock();try {
//                模拟网络延迟TimeUnit.SECONDS.sleep(1);if (ticket>0){System.out.println(Thread.currentThread().getName()+"售卖第"+ticket--+"张票");}else {System.out.println("卖完咯");break;}}catch (Exception e){e.printStackTrace();}finally {
//                释放锁reentrantLock.unlock();
//                线程让行，让其他线程也有机会运行Thread.yield();}}}
}
public class javaDemo {public static void main(String[] args) {Ticeket ticket = new Ticeket();
//        创建多个售卖对象for (int i=1;i<=5;i++){new Thread(()->{ticket.sale();},"售票员"+i).start();}}
}

 

问题引出：

        独占锁的最大弊端就在于其阻断了其他线程只允许一个线程工作。在很多情况下就会造成性能问题。所以引入了ReentranReadWritetLock（读写互斥锁）

  面试题：ReentrantLock 是如何实现可重入性的？

（1）什么是可重入性

一个线程持有锁时，当其他线程尝试获取该锁时，会被阻塞；而这个线程尝试获取自己持有锁时，如果成功说明该锁是可重入的，反之则不可重入。

（2）synchronized是如何实现可重入性

synchronized关键字经过编译后，会在同步块的前后分别形成monitorenter和monitorexit两个字节码指令。每个锁对象内部维护一个计数器，该计数器初始值为0，表示任何线程都可以获取该锁并执行相应的方法。根据虚拟机规范要求，在执行monitorenter指令时，首先要尝试获取对象的锁，如果这个对象没有被锁定，或者当前线程已经拥有了对象的锁，把锁的计数器+1，相应的在执行monitorexit指令后锁计数器-1，当计数器为0时，锁就被释放。如果获取对象锁失败，那当前线程就要阻塞等待，直到对象锁被另一个线程释放为止。

（3）ReentrantLock如何实现可重入性

ReentrantLock使用内部类Sync来管理锁，所以真正的获取锁是由Sync的实现类控制的。Sync有两个实现，分别为NonfairSync（非公公平锁）和FairSync（公平锁）。Sync通过继承AQS实现，在AQS中维护了一个private volatile int state来计算重入次数，避免频繁的持有释放操作带来的线程问题。

（4）代码分析

当一个线程在获取锁过程中，先判断state的值是否为0，如果是表示没有线程持有锁，就可以尝试获取锁。
当state的值不为0时，表示锁已经被一个线程占用了，这时会做一个判断current==getExclusiveOwnerThread()，这个方法返回的是当前持有锁的线程，这个判断是看当前持有锁的线程是不是自己，如果是自己，那么将state的值+1，表示重入返回即可。

---

 2.ReentRantReaderWriterLock（互斥读写锁）

         这个锁的机制和ReentrantLock区别并不大，但是将其权力拆分出来，分别为共享锁读，和互斥锁写锁。意思就是多线程想要修改数据就只允许其中一个线程修改其他等待，但是读取数据大家都可以随意读取。

ReentrantReaderWriter类的常用操作方法：

方法名	描述
readLock()	获取读锁，如果写锁被占用，则当前线程会被阻塞，直到写锁释放。
writeLock()	获取写锁，如果读锁或写锁被占用，则当前线程会被阻塞，直到所有的读锁和写锁都释放。

注意：实例化该对象用到开头提到框架中的ReadWriteLock接口进行向上转型得到对象。

如：ReaderWriteLock readWriterLock = new RenntrantReaderWriterLock();

以下案例通过ReentrantReadWriteLock实现一个银行10个ATM机，五个进行存款，五个进行读取账户信息

package Example2111;import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;class  Bank{private String name = "黄田";private double account = 0;private ReadWriteLock readWriteLock= new ReentrantReadWriteLock();
//    存钱public void write(double money){
//        设置写锁并开启this.readWriteLock.writeLock().lock();try {account = account+money;
//            模拟网络延迟TimeUnit.SECONDS.sleep(1);System.out.println("您正在使用"+Thread.currentThread().getName()+"存入存款:"+money+",当前账户余额为"+account);}catch (Exception e){e.printStackTrace();}finally {
//            更新完数据就可以解放写锁this.readWriteLock.writeLock().unlock();}}
//    读取存款public void Read(){
//        设置读取共享锁this.readWriteLock.readLock().lock();try {
//            模拟网络延迟TimeUnit.SECONDS.sleep(2);System.out.println("您正在使用"+Thread.currentThread().getName()+"读取账户信息:"+":当前账户人名称"+name+",账户人当前的余额为"+account);}catch (Exception e){e.printStackTrace();}finally {
//            读取完数据自动解锁this.readWriteLock.readLock().unlock();}}
}public class javaDemo {public static void main(String[] args) {Bank bank = new Bank();double moneys[]=new double[]{10,500,300,400};
//        五个ATM存款for (int i =1;i<=5;i++){new Thread(()->{for (int j=0;j<moneys.length;j++){bank.write(moneys[j]);}},"银行分行ATM"+i+"号取款机").start();}
//        五个ATM读取存款for (int i=5;i<=10;i++){new Thread(()->{bank.Read();},"银行分行ATM"+i).start();}}
}

面试题：synchronized 和 ReentrantLock 区别是什么？ 

synchronized 是和 if、else、for、while 一样的关键字，ReentrantLock 是类，这是二者的本质区别。既然 ReentrantLock 是类，那么它就提供了比synchronized 更多更灵活的特性，可以被继承、可以有方法、可以有各种各样的类变量

synchronized 早期的实现比较低效，对比 ReentrantLock，大多数场景性能都相差较大，但是在 Java 6 中对 synchronized 进行了非常多的改进。

相同点：两者都是可重入锁

两者都是可重入锁。“可重入锁”概念是：自己可以再次获取自己的内部锁。比如一个线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁的时候还是可以获取的，如果不可锁重入的话，就会造成死锁。同一个线程每次获取锁，锁的计数器都自增1，所以要等到锁的计数器下降为0时才能释放锁。

主要区别如下：

    ReentrantLock 使用起来比较灵活，但是必须有释放锁的配合动作；
    ReentrantLock 必须手动获取与释放锁，而 synchronized 不需要手动释放和开启锁；
    ReentrantLock 只适用于代码块锁，而 synchronized 可以修饰类、方法、变量等。
    二者的锁机制其实也是不一样的。ReentrantLock 底层调用的是 Unsafe 的park 方法加锁，synchronized 操作的应该是对象头中 mark word

Java中每一个对象都可以作为锁，这是synchronized实现同步的基础：

    普通同步方法，锁是当前实例对象
    静态同步方法，锁是当前类的class对象
    同步方法块，锁是括号里面的对象

---

3.StampedLock（无障碍锁）

        问题引出：虽然ReentrantLock和ReentrantReaderWriter解决了并发访问下数据写入安全和效率的问题，但是如果出现非常多的线程的时候，有可能会造成一些线程一直阻塞。调度减少的情况。为此JUC提供了StampedLock（无障碍锁）该所的特点在于若干个读线程之间互不干预。并且可以保证多个写线程的独占操作

以下是StampedLock类的常用方法：

方法	描述
readLock()	获取读锁。
tryReadLock()	尝试获取读锁，如果获取成功返回一个非负数，否则返回一个负数。
optimisticRead()	获取一个乐观读锁。
tryConvertToOptimisticRead(stamp)	尝试将锁从写锁转换为乐观读锁，如果转换成功返回一个非负数，否则返回一个负数。
tryConvertToReadLock()	尝试将锁从乐观读锁转换为普通读锁，如果转换成功返回一个非负数，否则返回一个负数。
writeLock()	获取写锁。
tryWriteLock()	尝试获取写锁，如果获取成功返回一个非负数，否则返回一个负数。
unlock()	释放锁。
unlockRead()	释放读锁。
unlockWrite()	释放写锁。
validate()	验证锁是否仍然有效。

  在StampedLock中有三种模式，乐观读，读，写用以提高并发处理性能，也用以转换锁的类型

案例代码：

假设我们有一个名为Point的类，表示二维平面上的一个点，其中包含x坐标和y坐标。我们希望实现对这个点的读写操作，并且要确保在写操作时其他线程不能同时读取或写入。

package Example2113;import org.omg.CORBA.BAD_CONTEXT;import java.util.Arrays;
import java.util.Random;
import java.util.concurrent.locks.StampedLock;class Point{
//    坐标double x;double y;private final StampedLock stampedLock = new StampedLock();public void set(double x,double y){
//        获取写锁long stamp = stampedLock.writeLock();try {this.x = x;this.y = y;}catch (Exception e){e.printStackTrace();}finally {
//            执行完后释放写锁stampedLock.unlockWrite(stamp);}}public double[] get(){
//        尝试获取乐观锁long stamp = stampedLock.tryOptimisticRead();double currentX =x;double currentY =y;
//        如果获取乐观锁失败则转为悲观锁if (!stampedLock.validate(stamp)){
//            获取stamp  = stampedLock.readLock();try {currentX =x;currentY = y;}catch (Exception e){e.printStackTrace();}finally {stampedLock.unlockRead(stamp);}}return new double[]{currentX, currentY};}
}public class javaDemo {public static void main(String[] args) {Point point = new Point();Random random = new Random(10);for (int i =0;i<5;i++){new Thread(()->{point.set(random.nextDouble(), random.nextDouble());double recieve[] = point.get();System.out.println(Arrays.toString(recieve));}).start();}
//        for (int j = 0;j<20;j++){
//            new Thread(()->{
//                double recieve[] = point.get();
//                System.out.println(Arrays.toString(recieve));
//            }).start();
//        }}
}

问：乐观锁和悲观锁是什么？

乐观锁和悲观锁是并发编程中两种不同的锁策略。

1. 乐观锁：乐观锁假设多个线程之间的并发冲突很少发生，所以它们可以同时读取共享数据而无需阻塞其他线程。在乐观锁中，线程首先尝试获取读锁，即乐观读取操作。如果没有发生写入冲突，那么乐观读锁会立即完成，并返回结果。但如果有其他线程在此期间进行了写入操作，则需要重新获取悲观锁再次尝试。

2. 悲观锁：悲观锁假设多个线程之间的并发冲突经常发生，因此每个线程在访问共享数据之前会悲观地认为会发生冲突，所以必须先获得独占锁（写锁）或共享锁（读锁）。只有持有锁的线程完成操作后，其他线程才能访问共享数据。悲观锁会导致其他线程阻塞等待锁的释放，从而降低并发性能。

问：为什么要用Stamp，代码中的long stamp是什么意思

stamp是一个标记，用于记录锁的状态。在读取锁和写入锁上下文之间传递，以确保数据一致性。

面试题 ：请谈谈 ReadWriteLock 和 StampedLock

ReadWriteLock包括两种子锁

（1）ReadWriteLock

ReadWriteLock 可以实现多个读锁同时进行，但是读与写和写于写互斥，只能有一个写锁线程在进行。

（2）StampedLock

StampedLock是Jdk在1.8提供的一种读写锁，相比较ReentrantReadWriteLock性能更好，因为ReentrantReadWriteLock在读写之间是互斥的，使用的是一种悲观策略，在读线程特别多的情况下，会造成写线程处于饥饿状态，虽然可以在初始化的时候设置为true指定为公平，但是吞吐量又下去了，而StampedLock是提供了一种乐观策略，更好的实现读写分离，并且吞吐量不会下降。

StampedLock包括三种锁：

（1）写锁writeLock：

writeLock是一个独占锁写锁，当一个线程获得该锁后，其他请求读锁或者写锁的线程阻塞， 获取成功后，会返回一个stamp（凭据）变量来表示该锁的版本，在释放锁时调用unlockWrite方法传递stamp参数。提供了非阻塞式获取锁tryWriteLock。

（2）悲观读锁readLock：

readLock是一个共享读锁，在没有线程获取写锁情况下，多个线程可以获取该锁。如果有写锁获取，那么其他线程请求读锁会被阻塞。悲观读锁会认为其他线程可能要对自己操作的数据进行修改，所以需要先对数据进行加锁，这是在读少写多的情况下考虑的。请求该锁成功后会返回一个stamp值，在释放锁时调用unlockRead方法传递stamp参数。提供了非阻塞式获取锁方法tryWriteLock。

（3）乐观读锁tryOptimisticRead：

tryOptimisticRead相对比悲观读锁，在操作数据前并没有通过CAS设置锁的状态，如果没有线程获取写锁，则返回一个非0的stamp变量，获取该stamp后在操作数据前还需要调用validate方法来判断期间是否有线程获取了写锁，如果是返回值为0则有线程获取写锁，如果不是0则可以使用stamp变量的锁来操作数据。由于tryOptimisticRead并没有修改锁状态，所以不需要释放锁。这是读多写少的情况下考虑的，不涉及CAS操作，所以效率较高，在保证数据一致性上需要复制一份要操作的变量到方法栈中，并且在操作数据时可能其他写线程已经修改了数据，而我们操作的是方法栈里面的数据，也就是一个快照，所以最多返回的不是最新的数据，但是一致性得到了保证。

面试题： 如何让 Java 的线程彼此同步？

1. synchronized
2. volatile
3. ReenreantLock

4. 使用局部变量实现线程同步

---

4.Condition（自定义锁）

        在JUC中允许用户进行锁对象的创建，可以通过Condition接口实现。经常用于生产者消费者模型中。

以下是Condition接口的常用方法

方法	描述
await()	当前线程等待，并释放锁。等价于Object.wait()
await(long time, TimeUnit unit)	当前线程等待一段时间，并释放锁。等价于Object.wait()
awaitUninterruptibly()	当前线程不可中断地等待，并释放锁。
signal()	唤醒一个等待该条件的线程。等价于Object.notify()
signalAll()	唤醒所有等待该条件的线程。等价于Object.notifyAll()

 使用案例：

假设有一个生产者-消费者模型，多个生产者线程负责向共享队列中生产数据，多个消费者线程负责从队列中消费数据。

package Example2114;import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;class SharedQueue {private final Lock lock = new ReentrantLock();private final Condition notFull = lock.newCondition();private final Condition notEmpty = lock.newCondition();private static final int MAX_SIZE = 10;private Queue<Integer> queue = new LinkedList<>();public void produce(int num) throws InterruptedException {lock.lock();try {while (queue.size() == MAX_SIZE) {// 队列满时，等待条件notFullnotFull.await();}queue.offer(num);System.out.println("Produced: " + num);// 唤醒一个等待notEmpty条件的线程notEmpty.signal();} finally {lock.unlock();}}public int consume() throws InterruptedException {lock.lock();try {while (queue.isEmpty()) {// 队列空时，等待条件notEmptynotEmpty.await();}int num = queue.poll();System.out.println("Consumed: " + num);// 唤醒一个等待notFull条件的线程notFull.signal();return num;} finally {lock.unlock();}}
}public class javaDemo {public static void main(String[] args) {SharedQueue sharedQueue = new SharedQueue();// 创建生产者线程Thread producer1 = new Thread(() -> {try {for (int i = 0; i < 20; i++) {sharedQueue.produce(i);}} catch (InterruptedException e) {e.printStackTrace();}});Thread producer2 = new Thread(() -> {try {for (int i = 20; i < 40; i++) {sharedQueue.produce(i);}} catch (InterruptedException e) {e.printStackTrace();}});// 创建消费者线程Thread consumer1 = new Thread(() -> {try {for (int i = 0; i < 20; i++) {sharedQueue.consume();}} catch (InterruptedException e) {e.printStackTrace();}});Thread consumer2 = new Thread(() -> {try {for (int i = 0; i < 20; i++) {sharedQueue.consume();}} catch (InterruptedException e) {e.printStackTrace();}});// 启动线程producer1.start();producer2.start();consumer1.start();consumer2.start();}
}

案例2：实现缓存队列的读取：

package Example2116;import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;//缓冲读取与写入
class DataBuffer{private final Lock lock = new ReentrantLock();private final Condition notUll = lock.newCondition();private final Condition notEmpty = lock.newCondition();private static final int MAX_SIZE = 20;Queue<String> queue = new LinkedList<>();public void Set(String str){
//        获取互斥锁lock.lock();try {
//            当缓冲区满了while (queue.size()==MAX_SIZE){notUll.await();}
//            模拟网络延迟TimeUnit.SECONDS.sleep(2);
//            放入数据并尝试唤醒等待的消费者线程queue.offer(str);System.out.println(Thread.currentThread().getName()+"放入数据"+str);notEmpty.signal();}catch (Exception e){e.printStackTrace();}finally {lock.unlock();}}public  String Get() throws Exception{
//        使用互斥锁lock.lock();try {while (queue.isEmpty()){notEmpty.await();}String string = queue.poll();System.out.println("获取到缓冲区内容"+string);notUll.signal();return string;}finally {
//            解锁lock.unlock();}}
}public class javaDemo {public static void main(String[] args) {DataBuffer dataBuffer = new DataBuffer();for (int i=0;i<5;i++){new Thread(()->{for (int j = 0;j<20;j++){dataBuffer.Set("数据"+j+"号数、");}},"生产者"+i+"号").start();}for (int i=0;i<50;i++){new Thread(()->{for (int j=0;j<100;j++){try {System.out.println("消费者取走"+dataBuffer.Get());}catch (Exception e){}}}).start();}}
}

 

面试题： Java 如何实现多线程之间的通讯和协作？

Java中线程通信协作的最常见的两种方式：

1、syncrhoized加锁的线程的Object类的wait()/notify()/notifyAll()

2、ReentrantLock类加锁的线程的Condition类的await()/signal()/signalAll()

---

5.LockSupport

由于JDK1.2时候为了预防死锁废除了一些Thread中的方法，但是一部分人认为这几个方法在操作上实际会更加直观，所以就有了LockSupport来替代这几个方法

LockSupport类的常用方法：

方法签名	说明
park()	阻塞当前线程，直到调用unpark(Thread thread)或者中断当前线程。
park(Object blocker)	阻塞当前线程，并关联一个特定的阻塞对象，用于调试和监控的目的。
parkNanos(long nanos)	阻塞当前线程，最多阻塞指定的纳秒数，参数nanos为等待时间。
parkNanos(Object blocker, long nanos)	阻塞当前线程，并关联一个特定的阻塞对象，最多阻塞指定的纳秒数。
unpark(Thread thread)	解除指定线程的阻塞状态。可以提前唤醒被阻塞的线程，使其继续执行。

案例代码：设置一个长辈线程和一个孩子辈线程，只有当长辈线程吃饭时候子线程才能进行吃饭

package Example2117;import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;public class javaDemo {public static void main(String[] args) {
//        子线程Thread son = new Thread(()->{
//            阻塞线程LockSupport.park();System.out.println("子辈开始吃饭");});
//        父辈线程Thread father = new Thread(()->{try {TimeUnit.SECONDS.sleep(3);System.out.println("长辈开始吃饭");}catch (Exception e){e.printStackTrace();}finally {LockSupport.unpark(son);}});son.start();father.start();}
}

 面试题：Java Concurrency API 中的 Lock 接口(Lock interface)是什么？对比同步它有什么优势？

Lock 接口比同步方法和同步块提供了更具扩展性的锁操作。他们允许更灵活的结构，可以具有完全不同的性质，并且可以支持多个相关类的条件对象。

它的优势有：

（1）可以使锁更公平

（2）可以使线程在等待锁的时候响应中断

（3）可以让线程尝试获取锁，并在无法获取锁的时候立即返回或者等待一段时间

（4）可以在不同的范围，以不同的顺序获取和释放锁

整体上来说 Lock 是 synchronized 的扩展版，Lock 提供了无条件的、可轮询的(tryLock 方法)、定时的(tryLock 带参方法)、可中断的(lockInterruptibly)、可多条件队列的(newCondition 方法)锁操作。另外 Lock 的实现类基本都支持非公平锁(默认)和公平锁，synchronized 只支持非公平锁，当然，在大部分情况下，非公平锁是高效的选择。

---