第七天 Java中的锁synchronized和ReentrantLock - 知乎

安宇雨 - 随手采集
2023-02-22 11:29:09
随手采集
0000-未整理-等待研究

我们都知道多线程中有锁的概念，

首先我们要声明一下java中每个对象都有一个monitor【或者说是锁】

为什么会有锁：通俗点说就是为了多线程访问共享数据的时候做到共享数据的安全，毕竟如果如果没有锁的话多个线程同时访问一个共享数据，每个线程都操作那么共享数据会被操作的不是每个线程原始操作的样子，

锁的是什么：我们知道使用我们可以使用wait notify notifyAll这些操作来唤醒线程和挂起线程，但是这些方法只能在synchronized内使用，而且wait notify notifyAll这些操作是Object操作类的，所以我们锁的是什么“对象”，而且wait notify notifyAll这些方法其实就是操作的monitor

synchronized

我们知道Object是java中的基类，所有的对象都是继承这个类来实现的，所以每个对象都有wait notify notifyAll的操作
wait ：作用就是让执行线程放弃monitor 【所有wait要在synchronized使用因为synchronized操作就是获取对象的monitor】
notify和notifyAll：就是唤醒对象等待队列里面的线程
下面我们先看一下 synchronized编译成源码会是什么样子的的

我们可以看到 synchronized在编译完其实就是monitorenter 和monitorexit
monitorenter ：监视器进入获取锁
monitorexit：监视器退出释放锁
所以synchronized获取的是谁的锁就很明白了，获取的是对象的，比如我们synchronized (object)这样写，那获取的就是object的锁，
synchronized 到底是什么：synchronized 就是保证同时只能有一个线程能获取对象锁的操作【互斥】，或者说同时只能有一个线程能进入临界区【临界区就是被synchronized 包括的代码，也可以认为是被monitorenter 和monitorexit包含的代码】，因为锁本来就在我们对象上面，synchronized 只是保证了同时只能有一个线程能获得它

@SpringBootTest public class TheahTest { ReentrantLock lock=new ReentrantLock(); private Object object=new Object(); @Test void zzlt() throws InterruptedException { Thread1 thread1=new Thread1(); Thread2 thread2=new Thread2(); thread1.start(); Thread.sleep(100); thread2.start(); } class Thread1 extends Thread{ @Override public void run() { synchronized (object){ System.out.println("Thread1"); try { Thread.sleep(300); System.out.println("ccc"); object.wait(); System.out.println("ppp"); } catch (Exception e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+"Thread1"); } } } class Thread2 extends Thread{ @Override public void run() { System.out.println("aaa"); synchronized (object){ object.notify(); System.out.println(Thread.currentThread().getName()+"Thread2"); } System.out.println(Thread.currentThread().getName()+"Thread2_notify"); } } }
　　输出结果

上面是一个很简单的加锁操作，但是他的具体流程是什么样的那
我们创建了两个线程在两个线程内做了synchronized 锁
第一步：thread1启动因为他是先启动的没有线程来竞争object的锁所以它进入了临界区输出了thread1，然后线程sleep（300）
第二步：主线程sleep（100）然后thread2启动，然后输出了aaa开始去竞争object的锁，但是锁已经被thread1占用，所以只能堵塞等thread1释放
第三步：thread1的sleep时间到期后开始继续执行，输出ccc然后线程挂起放入object的等待队列线程释放object的锁
第四步：因为thread1释放了object的锁【object.wait()，这个时候线程状态有RUNNING变成了waiting】，所以thread2可以获得object的锁然后进入临界区，执行object.notify()唤醒object等待队列里面的线程【就是thread1，这个时候因为只是唤醒但是thread2还没有释放锁所以thread1不会执行，它等待thread2释放锁】，然后thread2继续执行输出Thread-3Thread2，输出完Thread-3Thread2后thread2结束synchronized出临界区【释放object的锁】然后输出Thread-3Thread2_notify
第五步：thread1在第四步被唤醒，当thread2的synchronized结束出了临界区【释放锁了】thread1获得锁继续执行代码【object.wait();下面的代码】输出ppp，然后thread1也结束synchronized出临界区释放锁，输出Thread-2Thread1
上面就是一个synchronized加锁释放和唤醒的流程，流程图如下

ReentrantLock
有了上面的synchronized其实在来理解Condition就简单多了，我们来看一下 Condition的结构

这个是和wait notify notifyAll 对应的，其实就是为了和Lock配合实现wait notify notifyAll的功能
然后我们看一下 Lock的结构

我们可以看到在Lock里面直接定义了NewCondition，因为Condition是为了配合Lock来实现线程的挂起和唤醒
然后我们看看ReentrantLock 我们常用的一个锁

很明显继承了Lock，但是内部是一个sync，而且sync继承了AbstractQueuedSynchronizer同步器【通过cas算法实现】，所以说 ReentrantLock 是通过AQS同步器实现的，而synchronized是通过cpu的monitor实现的，所以说 ReentrantLock 在性能上面要比synchronized高很多，
ReentrantLock：底层是通过AQS同步器实现，而AQS同步器是通过Cas算法实现的，显示加锁，显示释放
synchronized：底层是通过monitor实现，cpu的监视器，自动加锁自动释放
Condition：相当于使用synchronized的时候对象object的等待队列
我们知道在ReentrantLock中我们要加锁需要调用lock方法显示加锁，而且他不在需要锁定对象，而且锁定了自己
Condition是个接口，基本的方法就是await()和signal()方法；
Condition依赖于Lock接口，生成一个Condition的基本代码是lock.newCondition()
调用Condition的await()和signal()方法，都必须在lock保护之内，就是说必须在lock.lock()和lock.unlock之间才可以使用
　　Conditon中的await()对应Object的wait()；
　　Condition中的signal()对应Object的notify()；
　　Condition中的signalAll()对应Object的notifyAll()

package springboottest01.autospringboottest01; import org.junit.jupiter.api.Test; import org.springframework.boot.test.context.SpringBootTest; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.ReentrantLock; @SpringBootTest public class ReenTest { private ReentrantLock lock=new ReentrantLock(); private Condition condition=lock.newCondition(); @Test void reent() throws InterruptedException { Thread thread1=new Thread(()->{ System.out.println("aaa"); lock.lock(); try { Thread.sleep(300); System.out.println("aaa-1"); condition.await(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("bbb"); lock.unlock(); }); Thread thread2=new Thread(()->{ System.out.println("ccc"); lock.lock(); System.out.println("ddd"); try { Thread.sleep(300); condition.signal(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("eee"); lock.unlock(); }); thread1.start(); Thread.sleep(100); thread2.start(); Thread.sleep(1000); } }