【JUC2022】第二章多线程锁

文章目录

【JUC2022】第二章多线程锁
一、乐观锁与悲观锁
- 1.悲观锁
- 2.乐观锁
二、八锁案例
- 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.字节码分析
- 2.底层原语
四、公平锁和非公平锁
五、可重入锁
六、死锁
- 1.是什么
- 2.手写死锁
- 3.死锁排查命令

一、乐观锁与悲观锁

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();
    }
}