synchronized 的实现原理与应用

野性酷女 2022-05-29 10:35 206阅读 0赞

synchronized 是多线程并发编程中的一员，被称为重量级锁，但在 Java SE 1.6 对 synchronized 进行了各种优化，引入偏向锁和轻量级锁，减少了获取锁和释放锁带来的性能消耗。

## synchronized 实现同步的基础 ##

Java 中的每一个对象都可以作为锁。具体表现为以下3种形式：

*  对于同步方法，锁是当前实例对象
 *  对于静态同步方法，锁是当前类的 Class 对象
 *  对于同步方法块，锁是 synchronized 括号里配置的对象

Java 中的每一个对象都可以作为锁，这也是为什么 wait 方法被定义在 Object 当中。当一个线程视图访问同步代码块时，它首先必须得到锁，退出或抛出异常时必须释放锁。

## JVM 规范中 synchronized 的实现原理 ##

JVM 基于 monitorenter 和 monitorexit 指令实现**代码块同步**，基于 ACC\_SYNCHRONIZED 指令前缀实现**方法同步**。  
    以代码块同步为例，monitorenter 指令是在编译后插入到同步代码块的开始位置，monitorexit 插入到代码块的结束处和异常处，JVM 保证每个 monitorenter 一定会有对应的 monitorexit 与之匹配。任何对象都有一个 monitor ，当 monitor 被持有后，它会出于锁定状态，线程执行到 monitorenter 指令时，将会尝试获取对象对应的 monitor 的所有权，即尝试获得对象的锁。

public static void main(String[] args) {
    // 对Synchronized Class对象进行加锁
    	synchronized (Test.class) {
    	}
    	// 静态同步方法，对Synchronized Class对象进行加锁
    	m();
    }
    
    public static synchronized void m() {
    }

// 方法修饰符，表示：public staticflags: ACC_PUBLIC, ACC_STATIC
    public static void main(java.lang.String[]);
    Code:
    stack=2, locals=1, args_size=1
    0: ldc #1　　// class com/murdock/books/multithread/book/Synchronized
    2: dup
    3: monitorenter　　// monitorenter：监视器进入，获取锁
    4: monitorexit　　// monitorexit：监视器退出，释放锁
    5: invokestatic　　#16 // Method m:()V
    8: return
    // 方法修饰符，表示： public static synchronized
    public static synchronized void m();
    flags: ACC_PUBLIC, ACC_STATIC, ACC_SYNCHRONIZED
    Code:
    stack=0, locals=0, args_size=0
    0: return

## synchronized 在 Java 对象头中的标志位 ##

synchronized 使用的锁是 Java 对象头的 Mark Word 的锁标志位。

Java 对象头的长度：

<table> 
 <thead> 
  <tr> 
   <th>长度</th> 
   <th>内容</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>32/64 bit</td> 
   <td>Mark Word</td> 
   <td>存储对象的 hashCode 或锁信息等</td> 
  </tr> 
  <tr> 
   <td>32/64 bit</td> 
   <td>Class Metadata Address</td> 
   <td>存储对象类型数据的指针</td> 
  </tr> 
  <tr> 
   <td>32/64 bit</td> 
   <td>Array length</td> 
   <td>数组的长度（如果当前对象是数组）</td> 
  </tr> 
 </tbody> 
</table>

Java 对象头里的 Mark Word 里默认存储对象的 HashCode、分代年龄和锁标记位。  
32位 JVM 的 Mark Word 的默认存储结构：

<table> 
 <thead> 
  <tr> 
   <th>锁状态</th> 
   <th>25bit</th> 
   <th>4bit</th> 
   <th>1bit 是否是偏向锁</th> 
   <th>2bit 锁标志位</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>无锁状态</td> 
   <td>对象头的 hashCode</td> 
   <td>对象分代年龄</td> 
   <td>0</td> 
   <td>01</td> 
  </tr> 
 </tbody> 
</table>

在运行期间 Mark Word 里存储的数据会随着锁标志位的变化而变化。  
Mark Word 锁标志位变化情况：

## 锁的升级与对比 ##

Java SE 1.6 中，锁一共有4种状态，级别从低到高依次是：无锁状态、偏向锁、轻量级锁和重量级锁，这几个状态会随着竞争情况逐渐升级，但不能降级。  
1、偏向锁  
    当一个线程访问同步块并获取锁时，会在对象头和栈帧中的锁记录里存储锁偏向的线程 ID，以后该线程在进入和退出同步块时不需要进行 CAS 操作来加锁和解锁，只需要简单的测试一下对象头的 Mark Word 里是否存储着指向当前线程的偏向锁，如测试成功，表示已经获得了锁，如果测试失败，使用 CAS 竞争锁，将 Mark Word 中偏向锁的标识设置成1，并将偏向锁指向当前线程。  
    偏向锁使用了一种等到竞争出现才释放锁的机制。偏向锁的撤销，需要等待全局安全点（在这个时间点上没有正在执行的字节码）。它会首先暂停拥有偏向锁的线程，然后检查该线程是否活着，如果还活着，遍历偏向对象的锁记录，使栈中的锁记录和对象头的 Mark Work 要么重新偏向于其他线程，要么恢复到无锁状态。  
2、轻量级锁  
    线程在执行同步块之前，JVM 会现在当前线程的栈帧中创建用于存储锁记录的空间，并将对象头中的 Mark Word 复制到锁记录中，然后线程尝试使用 CAS 将对象头中的 Mark Word 替换为指向锁记录的指针。如果成功，当前线程获得锁，如果失败，表示其他线程竞争锁，当前线程便尝试使用自旋获取锁。解锁时，会使用原子的 CAS 操作恢复对象头，如果成功，表示没有竞争发生，如果失败，表示当前锁存在竞争，锁就会膨胀成重量级锁。  
3、重量级锁  
    重量级锁即 synchronized。

## 实战注意点 ##

1.  对于相同的操作，使用同一个锁  
    例如减库存操作，我们要库存的服务作为锁，伪代码如下
    
        @Autowired
        private OrderService orderService;
        @Autowired
        private StockService stockService;
        // 创建订单
        Order order = new Order(Integer.parseInt(customerId), new Date(), totalMoney, 1);
        orderService.createOrder(order);
        // 减库存，这里的锁一定要使用库存那个对象，如果不使用锁，那么并发时，减库存有问题
        synchronized (stockService) {
            for (String key : goodsNumMap.keySet()) {
                stockService.decrease(key, goodsNumMap.get(key));
            }
        }
2.  同步代码尽可能的要小