锁的实现原理—3，Synchronized实现理解

java语言、Java虚拟机规范—官方文档

• https://docs.oracle.com/javase/specs/index.html

Synchronized概述：用法、作用

• 用法：修饰代码块、方法。PS：听说叫类锁和对象锁
• 作用：(个人理解) 在多线程环境下，通过Synchronized关键字，使其多个线程按照一定的先后顺序执行，从而保证单一线程安全。 PS：在此处使用Synchronized的一组同步集：当一个线程释放锁之后，另一个线程才能获取锁。

JVM中的同步实现方式

• 原文描述地址：3.14. Synchronization 其他类似描述信息：2.11.10. Synchronization
• JVM通过控制对象所关联的monitor的进入和退出实现同步，对于monitor进入和退出的调用，可以是显示的，也可以是隐式的。
• 在Java语言编码中，最常见的同步是对于方法的同步，方式的同步并不是显示的通过monitorenter和monitorexit实现，取而代之的是通过运行时常量池ACC_SYNCHRONIZED标记实现，此标识，将会在方法的调用中执行检查。
• 对于代码块的同步，使用monitorenter和monitorexit编译之后的效果如下：

void onlyMe(Foo f) {
    synchronized(f) {
        doSomething();
    }
}

Method void onlyMe(Foo)
0   aload_1             // Push f
1   dup                 // Duplicate it on the stack
2   astore_2            // Store duplicate in local variable 2
3   monitorenter        // Enter the monitor associated with f
4   aload_0             // Holding the monitor, pass this and...
5   invokevirtual #5    // ...call Example.doSomething()V
8   aload_2             // Push local variable 2 (f)
9   monitorexit         // Exit the monitor associated with f
10  goto 18             // Complete the method normally
13  astore_3            // In case of any throw, end up here
14  aload_2             // Push local variable 2 (f)
15  monitorexit         // Be sure to exit the monitor!
16  aload_3             // Push thrown value...
17  athrow              // ...and rethrow value to the invoker
18  return              // Return in the normal case
Exception table:
From    To      Target      Type
4       10      13          any
13      16      13          any

• 每个方法执行完成(正常或者异常)时，编译器会确保调用了一组相匹配的monitorenter和monitorexit方法。以确保，异常处理程序在捕捉异常后，能够为每一个相关联的执行代码执行monitorexit指令。

对象锁和类锁的区别

• 对象锁和类锁，其在本质上是一致的。这种一致性表现在：1，均是通过monitorenter和monitorexit指令实现。2，均只是一个资源被标识持有的符号。
• 对象锁和类锁不一样的地方：1，一个ClassA，它能有多个实例对象，但它只会有一个class对象。所以，当对象实例只有一个时，对象锁和类锁都差不多。2，类锁会存放标识字面量到运行时常量池，而对象锁随着编译后的代码，会存放在静态常量池。

一些代码示例

实例方法同步

public class SynchronizedClass {

    public synchronized void methodA(String name) {
       System.out.println(name);
    }

    public synchronized void methodB(String name) {
        System.out.println(name);
    }
    
}

• 我在工作中有见过这样的代码，我猜测写代码的最初预期，是希望多个线程执行A的时候同步阻塞，多个线程执行B的时候同步阻塞。但，coder是预期可以并发同时执行A和B的。结合到一般开发过程中的情况，这段代码可能会出什么问题？在什么情况下，这段代码又能够实现coder的预期？
• 像一般的话，采用springIOC管理bean，用的基本都是单例。对于一个SynchronizedClass来讲，它只有一个实例对象，也只有一个class对象，那么这个地方其实就等价了。 一旦一个线程拿到这个对象的monitor锁，比如调用了A方法，执行了moniterenter指令，那么别的线程是会在调用B方法时进行阻塞的，因为一个对象只会关联一个monitor对象。但假设spring的bean生成采用的是原型，coder的预期就实现了。

类方法同步/静态方法同步

public class SynchronizedClass {

    public static synchronized void methodC(String name){
        System.out.println(name + "哒哒");
    }

    public static void methodD(String name){
        synchronized (SynchronizedClass.class){
            System.out.println(name + "class");
        }
    }

}

• 不确定一个类会被生成几个实例对象，比如单例就一个，原型多个。如果一个方法要实现对于所有的线程执行进行同步，这时候用类锁可能会更合适。PS：有点事情打乱了， 脑壳子嗡嗡的。

Redis可重入锁问题

• 不管是对象锁还是类锁，假如我整多个JVM载入程序启动，然后似乎也锁不住呵。这时候才是不是就需要分布式锁了呀。。。啊啊啊啊啊。。。。。
• 用Redis实现一个可重入的锁：比如classA，用Redis的setNX指令，设置一个key值为classA，然后value值为当前的线程信息。 这样，当我再次进入一个锁的时候，如果我发现value值是我当前的线程，就直接进入。 有木有大佬可以说说这个东西会出啥问题呀？啊啊啊啊啊啊啊啊啊。。。。我。。。。。
• 我跟郭猴子，是真的无敌，巨无敌。