【JUC2022】第二章 多线程锁
文章目录
- 【JUC2022】第二章 多线程锁
- 一、乐观锁与悲观锁
- 二、八锁案例
- 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部手机，请问先打印邮件还是短信【结果：短信】
- 三、synchronized
- 四、公平锁和非公平锁
- 五、可重入锁
- 六、死锁
一、乐观锁与悲观锁
1.悲观锁
认为自己在使用数据的时候一定有别的线程来修改数据，因此在获取数据的时候会先加锁，确保数据不会被别的线程修改
synchronized关键字和Lock的实现类都是悲观锁
2.乐观锁
认为自己在使用数据时不会有别的线程修改数据或资源，所以不会添加锁
在Java中是通过使用无锁编程来实现的，即在更新数据的时候去判断之前有没有别的线程更新了这个数据
如果这个数据没有被更新，当前线程将自己修改的数据成功写入；
如果这个数据已经被其它线程更新，则根据不同的实现方式执行不同的操作，比如放弃修改、重试抢锁等等
【判断规则】
- 版本号机制Version
- 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_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: aload_0
5: new #2 // class java/lang/Object
8: dup
9: invokespecial #1 // Method java/lang/Object."<init>":()V
12: putfield #3 // Field object:Ljava/lang/Object;
15: return
public void m1();
Code:
0: aload_0
1: getfield #3 // Field object:Ljava/lang/Object;
4: dup
5: astore_1
6: monitorenter //获得锁
7: getstatic #4 // Field java/lang/System.out:Ljava/io/PrintStream;
10: ldc #5 // String -----hello synchronized code block
12: invokevirtual #6 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
15: aload_1
16: monitorexit //退出锁
17: goto 25
20: astore_2
21: aload_1
22: monitorexit //两次退出锁以保证异常情况也能退出锁
23: aload_2
24: athrow
25: return
Exception table:
from to target type
7 17 20 any
20 23 20 any
public 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();
}
}
公平锁
多个线程按照申请锁的顺序来获取锁，这里类似排队买票，先来的人先买，后来的人在队尾排队
非公平锁
多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程先获取锁，导致某个线程饥饿
为什么默认非公平锁
- 恢复挂起的线程是需要消耗时间的，从开发人员来看这个时间微乎其微，但是从 CPU 的角度看，这个时间差还是非常明显的，所以非公平锁能更充分地利用 CPU 的时间片
- 使用多线程必须要考虑线程切换的开销，非公平锁可以减少线程切换
五、可重入锁
可重入锁又名递归锁，是指同一个线程在外层方法获取锁的时候，再进入该线程的内层方法会自动获取锁，不会因为外层获取的锁没释放而阻塞
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 [进程号]，查看死锁信息
图形化界面
818
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
