多线程篇之8锁问题、字节码看Synchronized

八锁问题

①. 标准访问有ab两个线程,请问先打印邮件还是短信
②. sendEmail方法暂停3秒钟,请问先打印邮件还是短信
③. 新增一个普通的hello方法,请问先打印邮件还是hello
④. 有两部手机,请问先打印邮件还是短信
⑤. 两个静态同步方法,同1部手机,请问先打印邮件还是短信
⑥. 两个静态同步方法, 2部手机,请问先打印邮件还是短信
⑦. 1个静态同步方法,1个普通同步方法,同1部手机,请问先打印邮件还是短信
⑧. 1个静态同步方法,1个普通同步方法,2部手机,请问先打印邮件还是短信

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");
    }
}
public class Lock8Demo{
    public static void main(String[] args){//一切程序的入口,主线程
        Phone phone = new Phone();//资源类1
        Phone phone2 = new Phone();//资源类2

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

        //暂停毫秒
        try { TimeUnit.MILLISECONDS.sleep(300); } catch (InterruptedException e) { e.printStackTrace(); }

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

    }
}
/**
 *
 * ============================================
 *  1-2
 *  *  一个对象里面如果有多个synchronized方法,某一个时刻内,只要一个线程去调用其中的一个synchronized方法了,
 *  *  其它的线程都只能等待,换句话说,某一个时刻内,只能有唯一的一个线程去访问这些synchronized方法
 *  *  锁的是当前对象this,被锁定后,其它的线程都不能进入到当前对象的其它的synchronized方法
 *
 *  3-4
 *  *  加个普通方法后发现和同步锁无关
 *  *  换成两个对象后,不是同一把锁了,情况立刻变化。
 *
 *  5-6 都换成静态同步方法后,情况又变化
 *  三种 synchronized 锁的内容有一些差别:
 * 对于普通同步方法,锁的是当前实例对象,通常指this,具体的一部部手机,所有的普通同步方法用的都是同一把锁——实例对象本身,
 * 对于静态同步方法,锁的是当前类的Class对象,如Phone.class唯一的一个模板
 * 对于同步方法块,锁的是 synchronized 括号内的对象
 *
 *  7-8
 *    当一个线程试图访问同步代码时它首先必须得到锁,退出或抛出异常时必须释放锁。
 *  *
 *  *  所有的普通同步方法用的都是同一把锁——实例对象本身,就是new出来的具体实例对象本身,本类this
 *  *  也就是说如果一个实例对象的普通同步方法获取锁后,该实例对象的其他普通同步方法必须等待获取锁的方法释放锁后才能获取锁。
 *  *
 *  *  所有的静态同步方法用的也是同一把锁——类对象本身,就是我们说过的唯一模板Class
 *  *  具体实例对象this和唯一模板Class,这两把锁是两个不同的对象,所以静态同步方法与普通同步方法之间是不会有竞态条件的
 *  *  但是一旦一个静态同步方法获取锁后,其他的静态同步方法都必须等待该方法释放锁后才能获取锁。
 **/

javap到底是做什么的

通过反编译生成的字节码文件，我们可以深入的了解java代码的工作机制。但是，自己分析类文件结构太麻烦了！除了使用第三方的jclasslib工具之外，oracle官方也提供了工具：javap。

javap是jdk自带的反解析工具。它的作用就是根据class字节码文件，反解析出当前类对应的code区（字节码指令）、局部变量表、异常表和代码行偏移量映射表、常量池等信息。

通过局部变量表，我们可以查看局部变量的作用域范围、所在槽位等信息，甚至可以看到槽位复用等信息。

在这里插入图片描述
一般常用的是-v -l -c -p四个选项。
javap -l ：会输出行号和本地变量表信息；
javap -c ：会对当前class字节码进行反编译生成汇编代码；
javap -v： class字节码文件中除了包-c参数包含的内容外，还会输出行号、局部变量表信息、常量池等信息；
java -p：显示所有类和成员

使用javap查看synchronized

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

public class Main {

    Object object = new Object();

    public void m1(){
        synchronized (object){
            System.out.println("synchronized ----- demo");
        }
    }

    public static void main(String[] args) {

    }
}

使用 javap -c .\Main.class > Main_c.txt 命令反编译

Compiled from "Main.java"
public class com.test.Main {
  java.lang.Object object;

  public com.test.Main();
    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                           // aload_0 表示对this的操作，在static 方法中，aload_0表示对方法的第一参数的操作
       1: getfield      #3                  // Field object:Ljava/lang/Object; getfield指令表示获取指定类的实例域，并将其值压入栈顶
       4: dup                               // dup指令可以复制操作数栈栈顶的一个字，再将这个字压入栈。也就是对栈顶的内容做了个备份，此时操作数栈上有连续相同的两个对象地址。
       5: astore_1                          // astore_1指令，JVM从操作数栈顶部弹出一个引用类型或者returnAddress类型值，然后将该值存入由索引1指定的局部变量中,即将引用类型或者returnAddress类型值存入局部变量1。
       6: monitorenter                      // 线程执行monitorenter指令时尝试获取monitor的所有权
       7: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream; 获取指定类的静态域，并将其值压入栈顶
      10: ldc           #5                  // String synchronized ----- demo ldc指令将int、float、或者一个类、方法类型或方法句柄的符号引用、还可能是String型常量值从常量池中推送至栈顶。ldc指令可以加载String、方法类型或方法句柄的符号引用，但是如果要加载String、方法类型或方法句柄的符号引用，则会在类连接过程中重写ldc字节码指令为虚拟机内部使用的字节码指令_fast_aldc。
      12: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String; 指令用于调用对象的实例方法，根据对象的实际类型进行分派（虚方法分派），这也是Java语言中最常见的方法分派方式。
      15: aload_1                           // 将第二个引用类型本地变量推送至栈顶
      16: monitorexit                       // 释放锁
      17: goto          25                  // 目前主要的无条件跳转指令为 goto
      20: astore_2                          
      21: aload_1
      22: monitorexit                       //再次释放锁，如果方法出现异常，就会导致上面一个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
}

线程执行monitorenter指令时尝试获取monitor的所有权，通过monitorexit释放所有权

注：目前有两个monitorexit，第一个是方法执行完正常释放锁，另一个是如果方法出现异常系统级别的释放锁。

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

public class Main {

    public synchronized void m1() {
        System.out.println("synchronized ----- demo");
    }

    public static void main(String[] args) {

    }
}

使用 javap -v -p .\Main.class > Main_vp.txt 命令
在这里插入图片描述
调用指令将会检查方法的ACC_SYNCHRONIZED访问标志是否被设置,如果设置了,执行线程会将先持有monitor然后再执行方法,最后再方法完成(无论是正常完成还是非正常完成)时释放minotor

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

public class Main {

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

    public static void main(String[] args) {

    }
}