JUC并发编程与源码分析学习笔记(二)

package com.nanjing.juc.locks;

import java.util.concurrent.TimeUnit;

/**
 * 多线程锁之8锁案例编码演示
 *
 * @author xizheng
 * @date 2023-08-14 15:22:42
 */
class Phone{
    public static synchronized void sendEmail(){
        try {
            TimeUnit.SECONDS.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("-----sendEmail");
    }

    public static synchronized void sendSMS(){
        System.out.println("-----sendSMS");
    }

    public void hello(){
        System.out.println("------hello");
    }
}

/**
 * 题目：谈谈你对多线程锁的理解,8锁案例说明
 * 口诀：线程   操作  资源类
 * 8锁案例说明：
 * 1 标准访问有ab两个线程，请问先打印邮件还是短信
 * 2 sendEmail方法中加入暂停3秒钟，请问先打印邮件还是短信
 * 3 添加一个普通的hello方法，请问先打印邮件还是hello
 * 4 有两部手机，请问先打印邮件还是短信
 * 5 有两个静态同步方法，有1部手机，请问先打印邮件还是短信
 * 6 有两个静态同步方法，有2部手机，请问先打印邮件还是短信
 * 7 有1个静态同步方法，有1个普通同步方法,有1部手机，请问先打印邮件还是短信
 * 8 有1个静态同步方法，有1个普通同步方法,有2部手机，请问先打印邮件还是短信
 *
 * 笔记总结:
 * 1-2
 * *  * 一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了，
 * *  * 其它的线程都只能等待，换句话说，某一个时刻内，只能有唯一的一个线程去访问这些synchronized方法
 * *  * 锁的是当前对象this，被锁定后，其它的线程都不能进入到当前对象的其它的synchronized方法
 * 3-4
 * *  * 加个普通方法后发现和同步锁无关
 * *  * 换成两个对象后，不是同一把锁了，情况立刻变化。
 *
 * 5-6 都换成静态同步方法后，情况又变化
 * 三种 synchronized 锁的内容有一些差别:
 * 对于普通同步方法，锁的是当前实例对象，通常指this，具体的一部部手机，所有的普通同步方法用的都是同一把锁->实例对象本身，
 * 对于静态同步方法，锁的是当前类的Class对象，如Phone.class唯一的一个模板
 * 对于同步方法块，锁的是 synchronized括号内的对象
 *
 * 7-8
 *    当一个线程视图访问同步代码时它首先必须得到锁，正常退出或抛出异常时必须释放锁。
 * *  *
 * *  * 所有的普通同步方法用的都是同一把锁-实例对象本身，就是new出来的具体实例对象本身，本类this
 * *  * 也就是说如果一个实例对象的普通同步方法获取锁后，该实例对象的其他普通同步方法必须等待获取锁的方法释放锁后才能获取锁。
 * *  *
 * *  * 所有的静态同步方法用的也是同一把锁-类对象本身，就是我们说过的唯一模板Class
 * *  * 具体实例对象this和唯一模板Class，这两把锁是两个不同的对象，所以静态同步方法与普通同步方法之间是不会有竞态条件的
 * *  * 但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁才能获取锁。
 */
public class Lock8Demo {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        },"a").start();

        //暂停毫秒，保证a线程先启动
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
//            phone.sendSMS();
//            phone.hello();
            phone2.sendSMS();
        },"b").start();
    }
}

三十三、多线程锁之synchronized字节码分析

synchronized有三种应用方式

8种锁的案例实际体现在3个地方

作用于实例方法，当前实例加锁，进入同步代码前要获得当前实例的锁；

作用于代码块，对括号里配置的对象加锁。

作用域静态方法，当前类加锁，进去同步代码前要获得当前类对象的锁；

从字节码角度分析synchronized实现

javap -c ***.class文件反编译

synchronized同步代码块

javap -c .\LockSyncDemo.class（文件反编译）

synchronized同步代码块：实现使用的是monitorenter和monitorexit指令

synchronized普通同步方法

synchronized普通同步方法：调用指令将会检查方法的ACC_SYNCHRONIZED访问标志是否被设置。如果设置了，执行线程会将先持有monitor锁，然后再执行方法，最后在方法完成（无论是正常完成还是非正常完成）时释放monitor

synchronized静态同步方法

ACC_STATIC，ACC_SYNCHRONIZED访问标志区分该方法是否静态同步方法

2、（代码）locks目录下：LockSyncDemo.java

package com.nanjing.juc.locks;

/**
 * 锁同步演示
 *
 * @author xizheng
 * @date 2023-08-14 16:45:14
 */
public class LockSyncDemo {

    Object object = new Object();

    /**
     * monitorenter代表锁监视器获得了并进入
     *
     * 正常执行完毕以后会有
     * monitorexit说明要退出
     * synchronized的底层是依赖monitorenter和monitorexit来保证锁的获取和释放
     */
    public void m1(){
        synchronized (object){
            //也就是说这行代码，只要哪一个线程持有这把锁了，谁持有谁进来，进来以后干活，用完以后再将其释放
            System.out.println("----hello synchronized code block");
            //throw new RuntimeException("------exp");
        }
    }

    public synchronized void m2(){
        System.out.println("----hello synchronized m2");
    }

    public static synchronized void m3(){
        System.out.println("----hello static synchronized m3");
    }

    public static void main(String[] args) {

    }
}