Juc06_Lock8锁问题、字节码层面看Synchronized、反编译synchronized锁

1、Lock8 8锁问题

1. 标准访问有 a、b 两个线程，请问先打印邮件还是短信
2. sendEmail 方法暂停 3 秒钟，请问先打印邮件还是短信
3. 新增一个普通的 hello 方法，请问先打印邮件还是 hello
4. 有两部手机，请问先打印邮件还是短信
5. 两个静态同步方法，同 1 部手机，请问先打印邮件还是短信
6. 两个静态同步方法，2 部手机，请问先打印邮件还是短信
7. 1 个静态同步方法，1 个普通同步方法，同 1 部手机，请问先打印邮件还是短信
8. 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,这两把锁是两个不同的对象,所以静态同步方法与普通同步方法之间是不会有竞态条件的
 *  *  但是一旦一个静态同步方法获取锁后,其他的静态同步方法都必须等待该方法释放锁后才能获取锁。
 **/

2、从字节码角度分析 synchronized 实现

• 反编译：javap -v -p *.class > 类.txt 将进行输出到txt中
• synchronized 有三种应用方式

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

• synchronize 同步代码块

1. 实现使用的是 monitorenter 和 monitorexit 指令
2. 一定是一个 enter 和 两个 exit 吗？ 

      （不一定，如果方法中直接抛出异常处理，那么就是一个 monitorenter 和 monitorexit）

• synchronized 普通同步方法

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

• synchronized 静态同步方法 

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

3、反编译 synchronized 锁的是什么 

任何一个对象都可以成为一个锁，在 HotSpot 虚拟机中，monitor 采用 ObjectMonitor 实现

上述 C++ 源码解读

1. ObjectMonitor.java -- ObjectMonitor.cpp -- ObjectMonitor.hpp

2. ObjectMonitor.hpp（底层源码解析）