Java 锁机制总结

落日映苍穹つ 2021-12-18 07:07 285阅读 0赞

## 锁的种类 ##

*  独享锁 VS 共享锁
    
     *  独享锁：锁只能被一个线程持有（synchronized）
     *  共享锁：锁可以被多个程序所持有（读写锁）
 *  乐观锁 VS 悲观锁
    
     *  乐观锁：每次去拿数据的时候都乐观地认为别人不会修改，所以不进行加锁操作。乐观锁适用于多读的应用类型。（CAS，Atomic）
        
         *  CAS（Compare And Swap），其思想是：我认为V的值应该为 A，如果是，那么将 V 的值更新为 B，否则不修改并告诉V的值实际为多少。这样一来当有多个线程尝试修改同一个对象时，只有一个线程能够成功修改，因为一旦有一个线程修改成功了，那么其他线程就没法满足 V 的值是 A 了。其他线程修改失败之后不会被挂起，而是再次尝试修改。
     *  悲观锁：总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁。
 *  公平锁 VS 非公平锁
    
     *  公平锁：对于等待锁队列中的线程，按照先来先得的原则，给予锁。
     *  非公平锁：一个线程一执行到需要锁的地方，就尝试去要锁，失败了再进等待队列。这样一来，就能够大大减少唤醒线程的开销，但有可能会出现某线程饿死的情况。
        
         *  synchronized 是非公平锁，lock 可以是公平也可以非公平。
 *  其他概念
    
     *  可重入锁（synchronized 和 lock）：可重入性表明了锁的分配不是基于方法而是基于线程的。如：synchronized 了两个方法 method1, method2，method1 中调用了 method2，那么只要线程获得了 method1 的锁，那么它就一定能够进入 method2 而不需再申请锁。
     *  可中断锁（lockInterruptible()）：对于等待锁的线程，若等待时间过长，想中断该等待过程，让该线程去做其他的事，那么就需要可中断锁。

--------------------

## Java 锁的状态 ##

Java 锁状态的级别从低到高为：无锁状态、偏向锁状态、轻量级锁状态、重要级锁状态，而锁的状态是被记录在 Java 对象的对象头中。

*  Java 的对象头：由 Mark Word、指向类的指针、数组长度，其中 Mark Word 负责记录有关锁的信息
    
     *  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> 
          <tr> 
           <td>偏向锁</td> 
           <td>线程 ID 与 Epoch</td> 
           <td>分代年龄</td> 
           <td>1</td> 
           <td>01</td> 
          </tr> 
          <tr> 
           <td>轻量级锁</td> 
           <td>指向栈中的锁记录指针</td> 
           <td>同前</td> 
           <td>同前</td> 
           <td>00</td> 
          </tr> 
          <tr> 
           <td>重量级锁</td> 
           <td>指向重量级锁的指针</td> 
           <td>同前</td> 
           <td>同前</td> 
           <td>10</td> 
          </tr> 
          <tr> 
           <td>GC 标记</td> 
           <td>空</td> 
           <td></td> 
           <td></td> 
           <td>11</td> 
          </tr> 
         </tbody> 
        </table>
 *  偏向锁、轻量级锁概念的出现，都是为了减少同步唤醒的代价，若所有锁都为重量级的，那么所有等待锁的线程必须进入阻塞态
    
     *  偏向锁：大多数情况下，锁并不存在被大量线程竞争，而且总是由一个线程多次重复申请，那么这时只需要让偏向锁记录该线程 ID，这样当该线程又来声请锁的时候，就能快速获得锁了。
     *  轻量级锁：存在竞争，但是不强力且持有锁的线程会很快释放锁，在这种情况下，等待锁的线程可以处于自旋状态，而不必进入阻塞状态。
 *  Java 中锁的状态是一级一级往上升的，具体情况为：
    
     *  当未遇到同步代码块（即没有出现锁的时候），处于无锁状态。
     *  当对象被当作了同步锁，但当前只有一个线程 A 申请了该锁（没有竞争产生），那么对象的锁状态就会升级为偏向锁。
     *  当又有另一线程 B 来申请锁时，这时会检查当前占用该锁的线程 A 是否处于活跃状态或者仍然需要该锁，即是否有竞争会产生。若无，则偏向锁偏向 B，A 释放偏向锁。
     *  若有，那么偏向锁就会升级会轻量级锁。但若竞争进一步加大（有很多线程需求锁，且占用时间较长），那么锁就会进一步升级为重量级锁。

--------------------

## Java 锁机制的实现 ##

--------------------

#### synchronized ####

从上一节我们可以看出来，Java 中能够作为锁的只能是对象，所以 synchronized 的实现，也是通过对对象进行加锁实现的。

*  synchronized 的三种用法
    
     *  synchronized aMethod，锁一个类的方法，可以防止多个线程同时调用同一个对象的这个方法，但是能够同时调用。
     *  static synchronized aMethod，锁一个类的静态方法，可以防止多个线程同时这个类的该静态方法。
     *  synchronized (object)\{代码块\}，把 object 对象当作该代码块的锁
 *  synchronized 使用起来简单，但是有如下缺点
    
     *  不支持中断，可能造成其他线程等待很长的时间，甚至死锁。
     *  不支持读写锁，即读读操作是能够同时进行的，但是 synchronized 没法实现。

--------------------

#### Lock ####

Lock 是 **java.util.concurrent.locks** 包里的一个接口，对应的 ReentrantLock 类实现了该接口。

*  一般使用方法
    
        public class LockTest { private Lock alock = new ReentrantLock(); // 锁需要定义在具体使用锁的栈帧的上一层，即若在线程里定义的话，不同的线程会 new 出不同的锁，这样就不能实现同步了。 public static void main(String[] args) { Runnable r = () -> { alock.lock(); // 获得锁 try { // do something } catch(Exception e){ } finally{ alock.unlock(); } } Thread test = new Thread(r); test.start(); } }
 *  获得锁的方法
    
     *  lock(): 获取锁，若失败，则等待
     *  tryLock(long time, TimeUnit unit): 尝试获得锁，返回一个布尔值，表明是否获得到了锁。
     *  lockInterruptibly(): 若某一个线程使用这个方法等待获取锁，那么可以通过 thread.interrupt() 的方法去让他中断等待，干别的事。
 *  除此之外，**java.util.concurrent.locks** 包内还定义有 ReadWriteLock 接口，并有多种读写锁的实现类。

--------------------

#### volatile ####

一种轻量级同步机制，能够保证 volatile 修饰的变量具有可见性，但不具备原子性

*  原子性与可见性
    
     *  原子性：在多线程并发的条件下，对于变量的操作是线程安全的，不会受到其他线程的干扰。Atomatic 基于底层硬件处理器提供的原子指令，保证并发时线程安全。
     *  可见性：在多线程并发的条件下，对于变量的修改，其他线程中能获取到修改后的。volatile 通过对于值的操作，会立即更新到主存中，当其他线程获取该值会从主存中获取。
 *  使用方法与 synchronized 一样，都是 Java 关键词。

#### Atomatic ####

前面提到过 Atomatic 是一种乐观锁，它是通过操作的原子性来保证自己的线程安全的，即操作是不可被打断的，且具有排他性。当某一线程进行该原子操作时，其他想要执行该操作的线程只能处于自旋状态，等待该操作完成。

*  其实，这个给人的感觉，atomatic 有点像轻量级锁，不过这种线程的等待，不是通过软件实现的，而是通过硬件实现的（硬件上的原子操作）。
 *  不过这种依靠硬件上的原子操作实现的锁机制，导致 atomatic 的相关操作都比较基础。
 *  使用方法：参见 **java.util.concurrent.atomic**

转载于:https://www.cnblogs.com/Melles/p/10657611.html