【JUC2022】第二章 多线程锁

【JUC2022】第二章 多线程锁

一、乐观锁与悲观锁

1.悲观锁

认为自己在使用数据的时候一定有别的线程来修改数据，因此在获取数据的时候会先加锁，确保数据不会被别的线程修改

synchronized关键字和Lock的实现类都是悲观锁

2.乐观锁

认为自己在使用数据时不会有别的线程修改数据或资源，所以不会添加锁

在Java中是通过使用无锁编程来实现的，即在更新数据的时候去判断之前有没有别的线程更新了这个数据

如果这个数据没有被更新，当前线程将自己修改的数据成功写入；
如果这个数据已经被其它线程更新，则根据不同的实现方式执行不同的操作，比如放弃修改、重试抢锁等等

【判断规则】

1. 版本号机制Version
2. CAS（Compare And Swap，比较并交换）算法，Java原子类中的递增操作就是通过CAS自旋实现的

乐观锁适合读操作多的场景，不加锁的特点能够使其读操作的性能大幅提升

二、八锁案例

package com.sisyphus.Lock;import java.util.concurrent.TimeUnit;class Phone{    //资源类public static synchronized void sendEmail(){try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }System.out.println("-----sendEmail");}public synchronized void sendSMS(){System.out.println("-----sendSMS");}public void hello(){System.out.println("-----hello");}
}/** 题目：谈谈你对多线程锁的理解，8锁案例说明** 口诀：线程 操作 资源类** 八锁案例说明：* 1 标准情况，有a、b两个线程，请问先打印邮件还是短信【结果：邮件】* 2 sendEmail方法中加入暂停3秒钟，请问先打印邮件还是短信【结果：邮件】* 3 添加一个普通的hello方法，替换掉线程b中的sendSMS方法，请问先打印邮件还是hello【结果：hello】* 4 有两部手机，请问先打印邮件还是短信【结果：短信】* 5 将sendEmail和sendSMS修改为静态同步方法，有1部手机，请问先打印邮件还是短信【结果：邮件】* 6 sendEmail和sendSMS为静态同步方法，有2部手机，请问先打印邮件还是短信【结果：邮件】* 7 有1个静态同步方法，有1个普通同步方法，有1部手机，请问先打印邮件还是短信【结果：短信】* 8 有1个静态同步方法，有1个普通同步方法，有2部手机，请问先打印邮件还是短信【结果：短信】*/
public class Lock8Demo {public static void main(String[] args) {    //一切程序的入口Phone phone = new Phone();Phone phone2 = new Phone();new Thread(() -> {phone.sendEmail();},"a").start();//暂停200ms，确保线程a先启动try { TimeUnit.MILLISECONDS.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); }new Thread(() -> {//phone.sendSMS();//phone.hello();phone2.sendSMS();},"b").start();}
}

1.标准情况，有a、b两个线程，请问先打印邮件还是短信【结果：邮件】

sendEmail()和sendSMS()方法都被synchronized方法修饰，当synchronized修饰方法时，锁住的是整个对象的所有synchronized方法

a线程先动用了sendEmail()方法，因此a线程先获取了锁，b线程需要等待a线程执行完sendEmail()方法释放锁之后才能获取锁，最后执行sendSMS()方法

2.sendEmail方法中加入暂停3秒钟，请问先打印邮件还是短信【结果：邮件】

一个对象里面如果有多个synchronized方法，某一个时刻内，只要有一个线程去调用其中的一个synchronized方法，那么其它线程都只能等待。换句话说，某一个时刻内，只能有唯一的一个线程去访问这些synchronized方法

因此，当a线程访问sendEmail()获取了对象锁后，即使sendEmail()方法暂停了3秒，b线程也无法获取对象锁，也无法执行sendSMS()方法，只有当a线程的sendEmail()方法执行完成释放对象锁后，b线程才可以获取对象锁

3.添加一个普通的hello方法，替换掉线程b中的sendSMS方法，请问先打印邮件还是hello【结果：hello】

hello()没有被synchronizd修饰，因此访问该方法的线程并不需要参与锁竞争，在a线程执行sendEmail()的暂停期间，b线程访问hello()方法，并打印hello

4.有两部手机，请问先打印邮件还是短信【结果：短信】

有两部手机，即有两把对象锁，a线程获取其中一把，b线程获取另外一把，它们没有任何冲突，在a线程获取其中一把对象锁后执行sendEmalil()方法的暂停期间，b线程访问另一个对象的sendSMS()方法并打印短信

5.将sendEmail和sendSMS修改为静态同步方法，有1部手机，请问先打印邮件还是短信【结果：邮件】

当synchronized修饰静态方法时，锁住的是整个类的所有静态synchronized方法

6.sendEmail和sendSMS为静态同步方法，有2部手机，请问先打印邮件还是短信【结果：邮件】

当synchronized修饰静态方法时，锁住的是整个类的所有静态synchronized方法

7.有1个静态同步方法，有1个普通同步方法，有1部手机，请问先打印邮件还是短信【结果：短信】

一个类的类锁和对象锁并不冲突，当a线程访问sendEmail()获取了类锁（Class对象）后，b线程可以访问sendSMS()并获取对象锁

8.有1个静态同步方法，有1个普通同步方法，有2部手机，请问先打印邮件还是短信【结果：短信】

略

三、synchronized

1.字节码分析

synchronized 的作用范围

• 作用于实例方法，当前实例加锁，进入同步代码前要获得当前实例的锁
• 作用域于代码块，对括号里配置的对象加锁
• 作用于静态方法，当前类加锁，进入同步代码前要获得当前类对象的锁

字节码文件反汇编

javap -c xxx.class 对代码进行反汇编
javap -v xxx.class 输出附加信息（包括行号、本地变量表、反汇编等信息）

package com.sisyphus.Lock;public class LockSyncDemo {Object object = new Object();public void m1(){synchronized(object){System.out.println("-----hello synchronized code block");}}public static void main(String[] args) {}
}

执行javap -c

Compiled from "LockSyncDemo.java"
public class com.sisyphus.Lock.LockSyncDemo {java.lang.Object object;public com.sisyphus.Lock.LockSyncDemo();Code:0: aload_01: invokespecial #1                  // Method java/lang/Object."<init>":()V4: aload_05: new           #2                  // class java/lang/Object8: dup9: invokespecial #1                  // Method java/lang/Object."<init>":()V12: putfield      #3                  // Field object:Ljava/lang/Object;15: returnpublic void m1();Code:0: aload_01: getfield      #3                  // Field object:Ljava/lang/Object;4: dup5: astore_16: monitorenter						//获得锁7: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;10: ldc           #5                  // String -----hello synchronized code block12: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V15: aload_116: monitorexit						//退出锁17: goto          2520: astore_221: aload_122: monitorexit						//两次退出锁以保证异常情况也能退出锁23: aload_224: athrow25: returnException table:from    to  target type7    17    20   any20    23    20   anypublic static void main(java.lang.String[]);Code:0: return
}

结论：synchronized 通过管程 monitor 实现
管程是一种程序结构，结构内的多个子程序（对象或模块）形成的多个工作线程互斥访问共享资源。
这些共享资源一般是硬件设备或一群变量。对共享变量能够进行的所有操作集中在一个模块中，把信号量及其操作原语“封装”在一个对象内部。
管程实现了在一个时间点，最多只有一个线程在执行管程的某个子程序。管程提供了一种机制，管程可以看作一个软件模块，它是将共享的变量和对于这些共享变量的操作封装起来，形成一个具有一定接口的功能模块，进程可以调用管程来实现进程级别的并发控制

2.底层原语

ObjectMonitor.java→objectMonitor.cpp→objectMonitor.hpp

部分hpp代码

ObjectMonitor() {_header       = NULL;_count        = 0;			//用来记录当前线程获取锁的次数_waiters      = 0,_recursions   = 0;			//锁的重入次数_object       = NULL;_owner        = NULL;		//指向持有 ObjectMonitor 对象的线程_WaitSet      = NULL;		//存放处于 wait 状态的线程队列_WaitSetLock  = 0 ;_Responsible  = NULL ;_succ         = NULL ;_cxq          = NULL ;FreeNext      = NULL ;_EntryList    = NULL ;		//存放处于等待锁 block 状态的线程队列_SpinFreq     = 0 ;_SpinClock    = 0 ;OwnerIsThread = 0 ;_previous_owner_tid = 0;}

四、公平锁和非公平锁

package com.sisyphus.Lock;import java.util.concurrent.locks.ReentrantLock;class Ticket{private int number = 50;ReentrantLock lock = new ReentrantLock(true);	//true表示公平锁，false表示非公平锁，默认非公平public void sale(){lock.lock();try{if (number > 0){number--;System.out.println(Thread.currentThread().getName() + "卖出，还剩下：" + number);}}finally {lock.unlock();}}
}public class SaleTicketDemo {public static void main(String[] args) {Ticket ticket = new Ticket();new Thread(() -> {for (int i = 0; i < 55; i++) ticket.sale();},"a").start();new Thread(() -> {for (int i = 0; i < 55; i++) ticket.sale();},"b").start();new Thread(() -> {for (int i = 0; i < 55; i++) ticket.sale();},"c").start();}
}

公平锁
多个线程按照申请锁的顺序来获取锁，这里类似排队买票，先来的人先买，后来的人在队尾排队

非公平锁
多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程先获取锁，导致某个线程饥饿

为什么默认非公平锁

1. 恢复挂起的线程是需要消耗时间的，从开发人员来看这个时间微乎其微，但是从 CPU 的角度看，这个时间差还是非常明显的，所以非公平锁能更充分地利用 CPU 的时间片
2. 使用多线程必须要考虑线程切换的开销，非公平锁可以减少线程切换

五、可重入锁

可重入锁又名递归锁，是指同一个线程在外层方法获取锁的时候，再进入该线程的内层方法会自动获取锁，不会因为外层获取的锁没释放而阻塞

synchronized 可重入原理
每个锁对象都拥有一个锁计数器和一个指向持有该锁的线程的指针。当执行 monitorenter 时，如果目标锁对象的计数器为零，那么说明它没有被其他线程所持有，Java 虚拟机会将该锁对象的持有线程设置为当前线程，并且将其计数器加 1。在目标锁对象的计数器不为零的情况下，如果锁对象的持有线程是当前线程，那么 Java 虚拟机可以将其计数器加 1，否则需要等待，直至持有线程释放该锁。当执行 monitorexit 时，Java 虚拟机则需要将锁对象的计数器减 1。计数器为零，代表锁已释放。

六、死锁

1.是什么

死锁是指两个或两个以上的线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力干涉，那它们都将无法推进下去，如果系统资源充足，进程的资源请求都能够得到满足，死锁出现的可能性就很低，否则就会因争夺有限的资源而陷入死锁

2.手写死锁

package com.sisyphus.Lock;import java.sql.Time;
import java.util.concurrent.TimeUnit;public class DeadLock {//创建两个对象static Object a = new Object();static Object b = new Object();public static void main(String[] args) {new Thread(()->{synchronized (a){System.out.println(Thread.currentThread().getName() + " 持有锁 a，试图获得锁 b");try{TimeUnit.SECONDS.sleep(1);//睡眠 1 s}catch (InterruptedException e){e.printStackTrace();}synchronized (b){System.out.println(Thread.currentThread().getName() + "获得锁 b");    //死锁的情况无法获取}}},"AA").start();new Thread(()->{synchronized (b){System.out.println(Thread.currentThread().getName() + " 持有锁 b，试图获得锁 b");try{TimeUnit.SECONDS.sleep(1);//睡眠 1 s}catch (InterruptedException e){e.printStackTrace();}synchronized (a){System.out.println(Thread.currentThread().getName() + "获得锁 a");    //死锁的情况无法获取}}},"BB").start();}
}

3.死锁排查命令

原生命令
jps -l，找到 java 程序

jstack [进程号]，查看死锁信息

图形化界面