Java并发之synchronized实现原理

qq_39093474

已于 2022-12-25 10:25:21 修改

阅读量772

点赞数 1

分类专栏：多线程文章标签： java jvm 开发语言

于 2022-09-01 16:38:32 首次发布

多线程专栏收录该内容

18 篇文章 0 订阅

订阅专栏

线程安全是并发编程的重点，如果我们出现线程安全问题将会导致严重的生产问题（比如秒杀时多卖了一台手机）。并发编程中造成线程安全的诱因主要有两点：一是存在共享资源（也称为临界资源）。二是存在多条线程共同操作共享数据。因此为了解决这个问题，我们可能需要这样一个方案，当存在多个线程同时操作共享数据时，需要保证同一时刻只能有且只有一个线程来操作共享数据，其他线程必须等到该线程处理完数据再执行，这种方式有个名称叫做互斥锁。即是能通过互斥访问目的的锁，也就是说当一个共享数据被当前正在访问的线程加上互斥锁之后，在同一时刻，只能有一个线程来操作共享数据。其他线程只能处于等待的状态，直到当前线程处理完毕释放该锁，其他线程才能通过竞争锁然后去执行代码。在Java中，可以通过关键字synchronized和Lock接口的实现类ReentrantLock(这个本文不会讲述)来保证同一时刻，只有一个线程可以执行某个方法或者代码块（主要是对方法或者代码块中共享数据的操作）。同时我们还应该注意到synchronized另外一个重要的作用，synchronized可保证一个线程的变化(主要是共享数据的变化)被其他线程所看到（保证可见性，完全可以替代Volatile功能），这点确实也是很重要的。

1. synchronized三种使用方式

synchronized关键字在代码中主要有三种使用方式，下面分别介绍

修饰实例方法：作用于当前实例对象加锁，进入同步代码块前要获得当前实例的锁。
修饰静态方法：作用于当前类对象加锁，进入同步代码块前要获得当前类对象的锁。
修饰代码块：自己指定加锁对象，对给定对象加锁，进入同步代码块前要获得给定对象的锁。

1.1 synchronized作用于实例方法

什么是实例对象锁呢？就是调用被synchronized关键字修饰的实例方法的实例对象。必须是同一个实例对象才能互斥（下面的实例对象锁是testSync）。还有一点需要注意的是实例方法不包括静态方法。
代码如下：

/**
 * synchronized作用于实例方法
 */
public class TestSync implements Runnable {
    //共享变量
    int i=0;
    
    //synchronized 修饰实例方法
    public synchronized   void increase(){
        i++;
    }
    @Override
    public void run() {
        for (int j = 0; j <10000; j++) {
            increase();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //创建TestSync对象，这就是实例对象锁
        TestSync testSync=new TestSync();
         /**
         *  如果使用不同的锁，不能保证同一时刻只有一个线程执行，因为有了两把锁
         *  //TestSync testSync1=new TestSync();
         *  // Thread t1=new Thread(testSync);
         *  // Thread t2=new Thread(testSync1);
         */
        Thread t1=new Thread(testSync);
        Thread t2=new Thread(testSync);
        //启动线程t1，t2
        t1.start();
        t2.start();
        /**
         * join(): 等待这个线程结束，即在一个线程中调用other.join()，将等待other线程结束后才继续本线程。
         *  确保t1和t2先执行完
         */
        t1.join();
        t2.join();
        System.out.println("i= "+i);
    }
}
	 /**
     * 输出结果:
     * 20000
     */

在上述代码中，我们开启两个线程来操作同一个共享资源（即变量i），由于i++操作并不具备原子性，该操作是先读取值，然后写回一个新值。相当于原来的值加1，分两步完成。如果第二个线程在第一个线程读取旧值和写回新值之间读取i的值，那么第二个线程就会与第一个线程读取到相同的值，并执行相同的值的加1操作，这也就造成了线程安全问题。那么我们该如何解决呢？

答案就是使用synchronized关键字，因此我们必须在increase实例方法上使用synchronized修饰，以便保证线程安全，在这样的情况下，当前线程的锁便是实例对象testSync，注意Java中的线程同步锁可以是任意对象。从代码执行结果来看确实是正确的，倘若我们没有使用synchronized关键字，其最终输出结果就很可能小于20000，这便是synchronized关键字的作用。这里我们还需要意识到，当一个线程正在访问一个对象的 synchronized 实例方法，那么其他线程不能访问该对象的其他 synchronized 方法，毕竟一个对象只有一把锁，当一个线程获取了该对象的锁之后，其他线程无法获取该对象的锁，所以无法访问该对象的其他synchronized实例方法，但是其他线程还是可以访问该实例对象的其他非synchronized方法

注意：
上面我们说过一个对象只有一把锁，当一个线程获取了该对象的锁之后，其他线程无法获取该对象的锁，当然如果是一个线程t1需要访问实例对象testSync的synchronized方法increase(当前对象锁testSync)，另外一个线程t2需要访问实例对象testSync1的synchronized方法increase(当前对象锁testSync1).这样是允许的，因为这两个实例对象锁并不相同，此时如果两个线程操作数据并非共享的，线程安全是有保障的，但是如果两个线程操作的有共享数据，那么线程安全就有可能无法保证了，如下代码将演示出该现象

/**
 * synchronized作用于实例方法
 */
public class TestSync implements Runnable {
    //共享变量
     int i=0;

    //synchronized 修饰实例方法
    public synchronized   void increase(){
        i++;
    }
    @Override
    public void run() {
        for (int j = 0; j <10000; j++) {
            increase();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //创建TestSync对象
        TestSync testSync=new TestSync();
        //创建TestSync对象
        TestSync testSync1=new TestSync();
        Thread t1=new Thread(testSync);
        Thread t2=new Thread(testSync1);

        //启动线程t1，t2
        t1.start();
        t2.start();
        /**
         * join(): 等待这个线程结束，即在一个线程中调用other.join()，将等待other线程结束后才继续本线程。
         *  确保t1和t2先执行完
         */
        t1.join();
        t2.join();
        System.out.println("i= "+i);
    }
}

/**
     * 输出结果:
     * i= 18744
     */

上述代码与前面不同的是我们同时创建了两个新实例TestSync ，然后启动两个不同的线程对共享变量i进行操作，但很遗憾操作结果是18744而不是期望结果20000，因为上述代码犯了严重的错误，虽然我们使用synchronized修饰了increase方法，但却new了两个不同的实例对象，这也就意味着存在着两个不同的实例对象锁，因此t1和t2都会进入各自的对象锁，也就是说t1和t2线程使用的是不同的锁，因此线程安全是无法保证的。解决这种困境的的方式是将synchronized作用于静态的increase方法，这样的话，对象锁就当前类对象，由于无论创建多少个实例对象，但对于的类对象拥有只有一个，所有在这样的情况下对象锁就是唯一的。下面我们看看如何使用将synchronized作用于静态的increase方法。

1.2 synchronized作用于静态方法

当synchronized作用于静态方法时，其锁就是当前类的class对象锁。由于静态成员不属于任何一个实例对象，是类成员，因此可以通过class对象锁来控制静态成员的并发操作，需要注意的是，如果一个线程A调用一个实例对象所属类的静态static synchronized方法，另外一个线程B调用一个实例对象的实例方法（非static synchronized方法）。是允许的，不会发生互斥现象，因为访问静态 synchronized 方法占用的锁是当前类的class对象，而访问非静态 synchronized 方法占用的锁是当前实例对象锁，代码如下：

/**
 * synchronized作用于静态方法
 */
public class TestSync implements Runnable {
    //共享变量
    static int i=0;

    /**synchronized 修饰实例方法
     *  非静态，访问时锁不一样不会互斥
     *  锁是当前调用的实例对象，相当于this
     */
    public  synchronized   void increase(){
        i++;
    }
    /**
     *  作用于静态方法,锁是当前class对象,也就是
     *   TestSync类对应的class对象
     */

    public static synchronized   void staticIncrease(){
        i++;
    }
    @Override
    public void run() {
        for (int j = 0; j <10000; j++) {
            staticIncrease();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //创建TestSync对象
        TestSync testSync=new TestSync();
        //创建TestSync对象
        TestSync testSync1=new TestSync();
        Thread t1=new Thread(testSync);
        Thread t2=new Thread(testSync1);

        //启动线程t1，t2
        t1.start();
        t2.start();
        /**
         * join(): 等待这个线程结束，即在一个线程中调用other.join()，将等待other线程结束后才继续本线程。
         *  确保t1和t2先执行完
         */
        t1.join();
        t2.join();
        System.out.println("i= "+i);
    }
}

由于synchronized关键字修饰的是静态staticIncrease()方法，与修饰实例方法不同的是，其锁对象是当前类的class对象。注意代码中的increase()方法是实例方法，其对象锁是当前实例对象，如果别的线程调用该方法，将不会产生互斥现象，毕竟锁对象不同，但我们应该意识到这种情况下可能会发现线程安全问题(操作了共享静态变量i)。

1.3 synchronized同步代码块

除了使用关键字synchronized修饰实例方法和静态方法外，还可以使用同步代码块，在某些情况下，我们编写的方法体可能比较大，同时存在一些比较耗时的操作，而需要同步的代码只有一小部分，如果直接对整个方法进行同步操作，性能可能会降低，那样就得不偿失了，此时我们可以使用同步代码块的方式对需要同步的代码进行包裹，这样就无需对整个方法进行同步操作了，同步代码块的使用示例如下：

public class TestSync implements Runnable {
    static TestSync instance=new TestSync();
    //共享变量
    static int i=0;

    @Override
    public void run() {
        //省略其他耗时操作....
        //使用同步代码块对变量i进行同步操作,锁对象为instance
        synchronized (instance){
        for (int j = 0; j <10000; j++) {
                i++;
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //创建TestSync对象
        TestSync testSync=new TestSync();
        Thread t1=new Thread(testSync);
        Thread t2=new Thread(testSync);

        //启动线程t1，t2
        t1.start();
        t2.start();
        /**
         * join(): 等待这个线程结束，即在一个线程中调用other.join()，将等待other线程结束后才继续本线程。
         *  确保t1和t2先执行完
         */
        t1.join();
        t2.join();
        System.out.println("i= "+i);
    }
}

从代码看出，将synchronized作用于一个给定的实例对象instance，即当前实例对象就是锁对象，每次当线程进入synchronized包裹的代码块时就会要求当前线程持有instance实例对象锁，如果当前有其他线程正持有该对象锁，那么新到的线程就必须等待，这样也就保证了每次只有一个线程执行i++;操作。当然除了instance作为对象外，我们还可以使用this对象(代表当前实例)或者当前类的class对象作为锁，如下代码：

//this,当前实例对象锁
synchronized(this){
    for(int j=0;j<10000;j++){
        i++;
    }
}

//class对象锁
synchronized(TestSync .class){
    for(int j=0;j<10000;j++){
        i++;
    }
}

总结：
在项目开发中，一般使用同步代码块来进行同步操作，尽量遵守一个原则。

同步的范围越小越好

2. synchronized底层语义原理

任何一个对象都与一个Monitor相关联，当且一个Monitor被持有后，它将处于锁定状态。Java虚拟机中的同步（synchronized）基于进入和退出管程（Monitor）对象来实现的。无论是显式同步（有明确的monitorentetr和monitorexit指令，即同步代码块）还是隐式同步都是如此，在Java语言中，同步用的最多的地方可能是被synchronized修饰的同步方法，同步方法并不是由monitorenter 和 monitorexit 指令来实现同步的。而是由方法调用指令读取运行时常量池中方法的ACC_SYNCHRONIZED标准来隐式实现的，关于这点，稍后详细分析。下面先来了解一个概念Java对象头，这对深入理解synchronized实现原理非常关键。

2.1 Java对象头与Monitor

在JVM中，对象在内存中的布局分为三块区域，分别是：对象头，实例数据和对齐填充。如下图
在这里插入图片描述

实例变量：存放类的属性数据信息，包括父类的属性信息，如果是数组的实例部分还包括数组的长度，这部分内存按4字节对齐。
填充数据：由于虚拟机要求对象起始地址必须是8字节的整数倍，填充数据不是必须存在的，仅仅是为了字节对齐，这点了解即可。

Java对象头才是我们学习的重点，它是实现synchronized锁对象的基础。这点我们重点分析它，一般而言，synchronized使用的锁对象是存储在对象头里的，JVM中采用2个字来存储对象头(如果对象是数组则会分配3个字，多出来的1个字记录的是数组长度)，其主要结构是由Mark Word 和 Class Metadata Address 组成，其结构说明如下表：

上文提到的2个字大家肯定有所疑惑。
”字“是C++里的概念，因为JVM的底层是C++，在64位系统中，对象头默认是12字节（96bit）,是因为虚拟机默认开启了指针压缩。如果不开启是16字节（128bit）
1字=4字节即32bit

虚拟机位数	头对象结构	说明
32/64bit	Mark Word	存储对象的hashCode，锁信息或分代年龄或GC标志等信息
32/64bit	Class Metadata Address	类型指针指向对象的类元数据，JVM通过这个指针确定该对象是那个类的实例

其中Mark Work在默认情况下存储着对象的hashCode，分代年龄，锁标志位等，以下是32位JVM的Mark Word默认存储结构

锁状态	25bit	4bit	1bit是否是偏向锁	2bit 锁标志位
无锁状态	对象的hashCode	对象分代年龄	0	01

无锁状态：对象的HashCode + 对象分代年龄 + 状态位001

由于对象头的信息是与对象自身定义的数据没有关系的额外存储成本，因此考虑到JVM的空间效率，Mark Word被设计成位一个非固定的数据结构。以便存储更多有效的数据，它会根据对象的状态复用自己的存储空间，如64位JVM下，除了上述列出的Mark Word默认存储结构外，还有如下可能变化的结构：
在这里插入图片描述

其中轻量级锁和偏向锁是Java 6对synchronized锁进行优化后新增加的，稍后我们会简要分析，这里我们主要分析一下重量级锁也就是通常说的synchronized对象锁。锁标志位为10，其中指针指向的是monitor对象（也称为管程或监视器锁）的起始地址，每一个对象都存在一个monitor与之关联，对象与其monitor之间的关系有多种实现方式，如monitor可以和对象一起创建销毁或者当线程试图获取对象锁时自动生成。但是当一个monitor被某个线程持有后，它便处于锁定状态。在Java虚拟机(HotSpot)中，monitor是由ObjectMonitor实现的，其主要数据结构如下（位于HotSpot虚拟机源码ObjectMonitor.hpp文件，C++实现的）

ObjectMonitor() {
    _header       = NULL;
    _count        = 0; //记录个数
    _waiters      = 0,
    _recursions   = 0;
    _object       = NULL;
    _owner        = NULL;
    _WaitSet      = NULL; //处于wait状态的线程，会被加入到_WaitSet
    _WaitSetLock  = 0 ;
    _Responsible  = NULL ;
    _succ         = NULL ;
    _cxq          = NULL ;
    FreeNext      = NULL ;
    _EntryList    = NULL ; //处于等待锁block状态的线程，会被加入到该列表
    _SpinFreq     = 0 ;
    _SpinClock    = 0 ;
    OwnerIsThread = 0 ;
  }

ObjectMonitor中有两个队列，_WaitSet和_EntryList ，用来保存ObjectWaiter对象列表（每个等待锁的线程都会被封装成ObjectWaiter对象）。 _owner 指向持有ObjectMonitor对象的线程，当多个线程同时访问一段同步代码块时，首先会进入_EntryList集合，当线程获取到对象的monitor后进入_Owner 区域，并把monitor中的owner变量设置为当前线程同时monitor中的计数器count加1，若线程调用wait()方法，将释放当前持有的monitor，owner变量恢复为null，count自减1，同时该线程进入到_WaitSet集合中等待被唤醒。若当前线程执行完毕也将释放monitor（锁）并复位变量的值，以便其他线程获取monitor(锁)。如下图所示
在这里插入图片描述
由此看来，monitor对象存在于每个Java对象的对象头中(存储的指针的指向)，synchronized锁便是通过这种方式获取锁的，也是为什么Java中任意对象可以作为锁的原因，同时也是notify/notifyAll/wait等方法存在于顶级对象Object中的原因(关于这点稍后还会进行分析)，ok~，有了上述知识基础后，下面我们将进一步分析synchronized在字节码层面的具体语义实现。

2. 2 synchronized代码块底层原理

现在我们重新定义一个synchronized修饰的同步代码块，在代码块中操作共享变量i，如下

public class SyncCodeBlock {

   public int i;

   public void syncTask(){
       //同步代码库
       synchronized (this){
           i++;
       }
   }
}

编译上述代码并使用javap反编译后得到字节码如下(这里我们省略一部分没有必要的信息)：

  //构造函数
  public com.zejian.concurrencys.SyncCodeBlock();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 7: 0
  //===========主要看看syncTask方法实现================
  public void syncTask();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=3, locals=3, args_size=1
         0: aload_0
         1: dup
         2: astore_1
         3: monitorenter  //注意此处，进入同步方法
         4: aload_0
         5: dup
         6: getfield      #2             // Field i:I
         9: iconst_1
        10: iadd
        11: putfield      #2            // Field i:I
        14: aload_1
        15: monitorexit   //注意此处，退出同步方法
        16: goto          24
        19: astore_2
        20: aload_1
        21: monitorexit //注意此处，退出同步方法
        22: aload_2
        23: athrow
        24: return
      Exception table:
      //省略其他字节码.......
}
SourceFile: "SyncCodeBlock.java"

我们主要关注字节码中的如下代码

3: monitorenter  //进入同步方法
//..........省略其他  
15: monitorexit   //退出同步方法
16: goto          24
//省略其他.......
21: monitorexit //退出同步方法

从字节码中我们可以看出同步语句块使用的是monitorenter和monitorexit指令，其中monitorenter指令指向同步代码块开始的位置。monitorexit指令则指向同步代码块结束的位置。

当执行monitorenter指令时，当前线程将试图获取 objectref(即对象锁)所对应的monitor的持有权，当objectref的monitor的进入计数器为0时，那线程可以成功获得monitor。并将计数器值设置为1，取锁成功。如果当前线程已经获得了 objectref 的monitor的持有权，那它可以重入这个monitor(关于重入性稍后会分析)。重入后计数器的值也会加1，如果其他线程已经有了 objectref 的monitor的所有权，那么当前线程将阻塞，直到正在执行的线程执行完毕，即monitorexit指令被执行，执行线程将会释放monitor并把计数器减1，当计数器值为0时，其他线程才有机会持有monitor。

注意：
编译器将会确保无论方法通过何种方式完成，方法中调用过的每一条monitorenter指令都要执行其对应的monitorexit指令。不论这个方式是正常结束还是异常结束（就是会帮我们自动释放锁，而Lock需要我们手动释放锁）。为了保证方法在异常完成时monitorenter指令和monitorexit指令依然可以正确配对执行，编译器会自动产生一个异常处理器，这个异常处理器声明可处理的所有异常，它的目的就是用来执行monitorexit指令。从字节码中也可以看出多了一个monitorexit指令，它就是异常结束时被执行的释放monitor 的指令。

2. 3 synchronized方法底层原理

方法级的同步是隐式的，即无需通过字节码指令来控制，它实现在方法调用和返回操作之中。JVM可以从方法常量池中的方法表结构(method_info Structure) 中ACC_SYNCHRONIZED访问标志区分一个方法是否是同步方法，当方法调用时，调用指令将会检查方法的ACC_SYNCHRONIZED访问标志是否被设置，如果设置了，执行线程将先持有monitor（虚拟机规范中用的是管程一词），然后再执行方法。最后等方法完成时（无论是真正常完成还是非正常完成）释放monitor。在方法执行期间，执行线程持有了monitor，其他任何线程都无法在获得同一个monitor。如果一个同步方法执行期间抛出了异常，并且在方法内部无法处理该异常，那这个同步方法持有的monitor将在异常抛到同步方法之外时自动释放，下面我们看看字节码层面如何实现：

public class SyncMethod {

   public int i;

   public synchronized void syncTask(){
           i++;
   }
}

使用javap反编译后的字节码如下：

public class com.zejian.concurrencys.SyncMethod
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool;

   //省略没必要的字节码
  //==================syncTask方法======================
  public synchronized void syncTask();
    descriptor: ()V
    //方法标识ACC_PUBLIC代表public修饰，ACC_SYNCHRONIZED指明该方法为同步方法
    flags: ACC_PUBLIC, ACC_SYNCHRONIZED
    Code:
      stack=3, locals=1, args_size=1
         0: aload_0
         1: dup
         2: getfield      #2                  // Field i:I
         5: iconst_1
         6: iadd
         7: putfield      #2                  // Field i:I
        10: return
      LineNumberTable:
        line 12: 0
        line 13: 10
}
SourceFile: "SyncMethod.java"

从字节码中可以看此，synchronized修饰的方法并没有monitorenter指令和monitorexit指令，取而代之的是一个ACC_SYNCHRONIZED标识，该标识指明了该方法是一个同步方法，JVM会通过该ACC_SYNCHRONIZED访问标志来辨别一个方法是否声明为同步方法，从而进行相应的同步调用。这便是synchronized锁在同步代码块和同步方法上实现的基本原理。同时我们还必须注意到在Java早期版本中，synchronized锁属于重量级锁，效率低下，因为监视器锁（monitor）是依赖于底层的操作系统的Mutex Lock来实现的，而操作系统实现线程之间的切换时需要从用户态切转到核心态，这个状态之间的转换需要相对比较长的时间，时间成本相对较高，这也是为什么早期的synchronized效率低的原因。庆幸的是在Java 6之后Java官方对从JVM层面对synchronized较大优化，所以现在的synchronized锁效率也优化得很不错了，Java 6之后，为了减少获得锁和释放锁所带来的性能消耗，引入了轻量级锁和偏向锁，接下来我们将简单了解一下Java官方在JVM层面对synchronized锁的优化。

3. Monitor Record什么是

Monitor？我们可以把它理解为一个同步工具，也可以描述为一种同步机制，它通常被描述为一个对象。

与一切皆对象一样，所有的Java对象是天生的Monitor，每一个Java对象都有成为Monitor的潜质，因为在Java的设计中，每一个Java对象自打娘胎里出来就带了一把看不见的锁，它叫做内部锁或者Monitor锁。

Monitor 是线程私有的数据结构，每一个线程都有一个可用monitor record列表，同时还有一个全局的可用列表。每一个被锁住的对象都会和一个monitor关联（对象头的MarkWord中的LockWord指向monitor的起始地址），同时monitor中有一个Owner字段存放拥有该锁的线程的唯一标识，表示该锁被这个线程占用。其结构如下：

在这里插入图片描述
Owner：初始时为NULL表示当前没有任何线程拥有该monitor record，当线程成功拥有该锁后保存线程唯一标识，当锁被释放时又设置为NULL；

EntryQ:关联一个系统互斥锁（semaphore），阻塞所有试图锁住monitor record失败的线程。

RcThis:表示blocked或waiting在该monitor record上的所有线程的个数。

Nest:用来实现重入锁的计数。

HashCode:保存从对象头拷贝过来的HashCode值（可能还包含GC age）。

Candidate:用来避免不必要的阻塞或等待线程唤醒，因为每一次只有一个线程能够成功拥有锁，如果每次前一个释放锁的线程唤醒所有正在阻塞或等待的线程，会引起不必要的上下文切换（从阻塞到就绪然后因为竞争锁失败又被阻塞）从而导致性能严重下降。Candidate只有两种可能的值0表示没有需要唤醒的线程1表示要唤醒一个继任线程来竞争锁。

4. Java虚拟机对synchronized的优化

在Java 6里锁一共有四种状态，无锁状态，偏向锁状态，轻量级锁状态和重量级锁状态。随着锁的竞争，锁可以从偏向锁升级到轻量级锁，再升级到重量级锁，但锁的升级是单向的，也就是说只能从低到高升级，不会出现锁的降级。目的是为了提高获得锁和释放锁的效率。

无锁 --> 偏向锁 --> 轻量级 --> 重量级

4.1 偏向锁

引入背景：偏向锁是Java6之后加入的新锁，它是一种针对加锁操作的的优化手段。经过研究发现，在大多数情况下，锁不仅不存在多线程竞争，而且总是由同一线程多次获得，因此为了减少同一线程获得锁(会涉及到一些CAS操作,耗时)的代价而引入偏向锁。减少不必要的CAS操作。

加锁：当一个线程访问同步块并获取锁时，会在对象头和栈帧中的锁记录里存储锁偏向的线程ID，以后该线程在进入和退出同步块时，不需要花费CAS操作来加锁和解锁。而只需简单测试一下对象头的Mark Word中是否存储着指向当前线程的偏向锁。如果测试成功，表示线程已经获得了锁。开始指向同步块。如果测试失败，则需要再测试一下Mark Word中偏向锁的标识是否设置成1（表示当前是偏向锁）。如果没有设置，则使用CAS竞争锁。如果设置了，则尝试使用CAS操作将对象头的偏向锁指向当前线程（此时会引发竞争，偏向锁会升级为轻量级锁）。
获取锁的步骤：

检测Mark Word是否为偏向锁状态，即是否是偏向锁1，锁标识位01。
若当前是偏向锁，则测试线程ID是否为当前线程ID，如果是，则执行步骤（5），否则执行步骤（3）；
如果线程ID不是当前线程ID，则通过CAS操作竞争锁，竞争成功，则将对象头Mark Word的线程ID替换为当前线程ID。否则指向步骤（4）。
通过CAS操作竞争锁失败，证明当前存在多线程竞争情况，当到达全局安全点，获得偏向锁的线程被挂起，偏向锁升级为轻量级锁，然后被阻塞在安全点的线程继续往下执行同步代码块。
执行同步代码块。

释放锁：
偏向锁的释放采用了一种只有竞争才会释放锁的机制，线程是不会主动去释放偏向锁，需要等待其他线程来竞争，偏向锁的撤销需要等待全局安全点（这个时间点上是没有正在执行的代码），其步骤如下：

暂停拥有偏向锁的线程，判断锁对象是否还处于被锁定状态。
撤销偏向锁，恢复到无锁状态（01）或轻量级状态。

膨胀过程：当前线程执行CAS获取偏向锁失败（这一步是偏向锁的关键），表示在该锁对象上存在竞争并且这个时候另外一个线程获得偏向锁的所有权，当到达全局安全点时获得偏向锁的线程被挂起，并从偏向锁所有者的私有Monitor Record列表中获取一个空闲的记录，并将Object设置LightWeight Lock状态并且Mark Word中的LockRecord指向刚才持有偏向锁线程的Monitor record，最后被阻塞在安全点的线程被释放，进入到轻量级锁的执行路径中，同时被撤销偏向锁的线程继续往下执行同步代码。

下图是偏向锁的获取和释放流程
在这里插入图片描述

4.2 轻量级锁

引入轻量级锁的主要目的是在没有多线程竞争的前提下，减少传统的重量级锁使用操作系统互斥量产生的性能消耗，当关闭偏向锁功能或者多个线程竞争偏向锁导致偏向锁升级为轻量级锁，对于轻量级锁，其性能提升的依据是“对于绝大部分的锁，在整个同步周期内都不存在竞争”，如果打破了这个依据则除了互斥的开销外，还有额外的CAS操作，因此在有多线程竞争的情况下，轻量级锁比重量级锁更慢；轻量级锁所适应的场景是线程交替执行同步块的场合，如果存在同一时间访问同一锁的场合，就会导致轻量级锁膨胀为重量级锁。

获取锁：

判断当前对象是否处于无锁状态（hashCode、0、01），若是，则JVM首先在当前线程的栈帧中建立一个名为锁记录（Lock Record）的空间，用于存储锁对象目前的Mark Word的拷贝（官方把这份拷贝加了一个Displaced前缀，即Displaced Mark Word）。否则执行步骤（3）；
JVM利用CAS操作尝试将对象的Mark Word更新为指向Lock Record的指针，如果成功表示竞争到锁，则将锁标志位变成00（表示此对象处于轻量级锁状态），执行同步操作，如果失败则执行步骤（3）。
判断当前对象的Mark Word是否当前线程的栈帧，如果是则表示当前线程已持有当前对象的锁，则直接执行同步代码块，否则只能说明该锁对象已经被其他线程抢占了，这时轻量级锁膨胀为重量级锁，锁标志位为10，后面等待的线程将会被阻塞。

释放锁：
轻量级锁的释放也是通过CAS操作来进行的，主要步骤如下

取出在获取轻量级锁保存在Displaced Mark Word中的数据；
用CAS操作将取出的数据替换当前对象的Mark Word中，如果成功，则说明释放锁成功，否则执行（3）；
如果CAS操作替换失败，说明有其他线程尝试获取该锁，则需要在释放锁的同时需要唤醒被挂起的线程。

下图是轻量级锁的获取和释放过程
在这里插入图片描述

4.3 重量级锁

重量级锁通过对象内部的监视器（monitor）实现，其中monitor的本质是依赖于底层操作系统的Mutex Lock实现，操作系统实现线程之间的切换需要从用户态到内核态的切换，切换成本非常高。

4.4 自旋锁

线程的阻塞和唤醒需要CPU从用户态转为核心态，频繁的阻塞和唤醒对CPU来说是一件负担很重的工作，势必会给系统的并发性能带来很大的压力。同时我们发现在许多应用上面，对象锁的锁状态只会持续很短一段时间，为了这一段很短的时间频繁地阻塞和唤醒线程是非常不值得的。所以引入自旋锁。

何谓自旋锁？

所谓自旋锁，就是让该线程等待一段时间，不会被立即挂起，看持有锁的线程是否会很快释放锁。怎么等待呢？执行一段无意义的循环即可（自旋）。

自旋等待不能替代阻塞，先不说对处理器数量的要求（多核，貌似现在没有单核的处理器了），虽然它可以避免线程切换带来的开销，但是它占用了处理器的时间。如果持有锁的线程很快就释放了锁，那么自旋的效率就非常好，反之，自旋的线程就会白白消耗掉处理的资源，它不会做任何有意义的工作，典型的占着茅坑不拉屎，这样反而会带来性能上的浪费。所以说，自旋等待的时间（自旋的次数）必须要有一个限度，如果自旋超过了定义的时间仍然没有获取到锁，则应该被挂起。

自旋锁在JDK 1.4.2中引入，默认关闭，但是可以使用-XX:+UseSpinning开开启，在JDK1.6中默认开启。同时自旋的默认次数为10次，可以通过参数-XX:PreBlockSpin来调整；

如果通过参数-XX:preBlockSpin来调整自旋锁的自旋次数，会带来诸多不便。假如我将参数调整为10，但是系统很多线程都是等你刚刚退出的时候就释放了锁（假如你多自旋一两次就可以获取锁），你是不是很尴尬。于是JDK1.6引入自适应的自旋锁，让虚拟机会变得越来越聪明。

4.5 适应自旋锁

JDK 1.6引入了更加聪明的自旋锁，即自适应自旋锁。所谓自适应就意味着自旋的次数不再是固定的，它是由前一次在同一个锁上的自旋时间及锁的拥有者的状态来决定。它怎么做呢？线程如果自旋成功了，那么下次自旋的次数会更加多，因为虚拟机认为既然上次成功了，那么此次自旋也很有可能会再次成功，那么它就会允许自旋等待持续的次数更多。反之，如果对于某个锁，很少有自旋能够成功的，那么在以后要或者这个锁的时候自旋的次数会减少甚至省略掉自旋过程，以免浪费处理器资源。

有了自适应自旋锁，随着程序运行和性能监控信息的不断完善，虚拟机对程序锁的状况预测会越来越准确，虚拟机会变得越来越聪明

4.6 锁消除

为了保证数据的完整性，我们在进行操作时需要对这部分操作进行同步控制，但是在有些情况下，JVM检测到不可能存在共享数据竞争，这时JVM会对这些同步锁进行锁消除。锁消除的依据是逃逸分析的数据支持。

锁消除可以说是虚拟机另外一种锁的优化，这种优化更彻底，Java虚拟机在JIT编译时（可以简单理解为当某段代码即将第一次被执行时进行编译，又称即时编译）。通过对运行上下文的扫描，去除不可能存在共享资源竞争的锁，通过这种方式消除没有必要的锁，可以节省毫无意义的请求锁时间，如下StringBuffer的append是一个同步方法，但是在add方法中的StringBuffer属于一个局部变量，并且不会被其他线程所使用，因此StringBuffer不可能存在共享资源竞争的情景，JVM会自动将其锁消除。

public void add(String str1, String str2) {
        //StringBuffer是线程安全,由于sb只会在append方法中使用,不可能被其他线程引用
        //因此sb属于不可能共享的资源,JVM会自动消除内部的锁
        StringBuffer sb = new StringBuffer();
        sb.append(str1).append(str2);
    }

4.7 锁粗化

我们知道在使用同步锁的时候，需要让同步块的作用范围尽可能小，仅在共享数据的实际作用域中才进行同步，这样做的目的是为了使需要同步的操作数量尽可能缩小，如果存在锁竞争，那么等待锁的线程也能尽快拿到锁。

在大多数的情况下，上述观点是正确的，我也一直坚持着这个观点。但是如果一系列的连续加锁解锁操作，可能会导致不必要的性能损耗，所以引入锁粗化的概念。

锁粗话概念比较好理解，就是将多个连续的加锁、解锁操作连接在一起，扩展成一个范围更大的锁。如下面实例：vector每次add的时候都需要加锁操作，JVM检测到对同一个对象（vector）连续加锁、解锁操作，会合并一个更大范围的加锁、解锁操作，即加锁解锁操作会移到for循环之外。

    public void vectorTest(){
        Vector<String> vector = new Vector<String>();
        for(int i = 0 ; i < 10 ; i++){
            vector.add(i + "");
        }

        System.out.println(vector);
    }

5. synchronized的可重入性

从互斥锁的设计上来说，当一个线程试图操作一个由其他线程持有的对象锁的临界资源时，将会处于阻塞状态，但当一个线程再次请求自己持有对象锁的临界资源时，这种情况属于重入锁，请求将会成功，在java中synchronized是基于原子性的内部锁机制，是可重入的，因此在一个线程调用synchronized方法的同时在其方法体内部调用该对象另一个synchronized方法，也就是说一个线程得到一个对象锁后再次请求该对象锁，是允许的，这就是synchronized的可重入性。如下：

public void run() {
        for(int j=0;j<1000000;j++){

            //this,当前实例对象锁
            synchronized(this){
                i++;
                increase();//synchronized的可重入性
            }
        }
    }

    public synchronized void increase(){
        j++;
    }

正如代码所演示的，在获取当前实例对象锁后进入synchronized代码块执行同步代码，并在代码块中调用了当前实例对象的另外一个synchronized方法，再次请求当前实例锁时，将被允许，进而执行方法体代码，这就是重入锁最直接的体现，需要特别注意另外一种情况，当子类继承父类时，子类也是可以通过可重入锁调用父类的同步方法。注意由于synchronized是基于monitor实现的，因此每次重入，monitor中的计数器仍会加1。

6. 线程中断与synchronized

6.1 线程中断

正如中断二字所表达的意义，在线程运行(run方法)中间打断它，在Java中，提供了以下3个有关线程中断的方法

//中断线程（实例方法）
public void Thread.interrupt();

//判断线程是否被中断（实例方法）
public boolean Thread.isInterrupted();

//判断是否被中断并清除当前中断状态（静态方法）
public static boolean Thread.interrupted();

当一个线程处于被阻塞状态或者试图执行一个阻塞操作时，使用Thread.interrupt()方式中断该线程，注意此时将会抛出一个InterruptedException的异常，同时中断状态将会被复位(由中断状态改为非中断状态)，如下代码将演示该过程：

public class InterruputSleepThread3 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread() {
            @Override
            public void run() {
                //while在try中，通过异常中断就可以退出run循环
                try {
                    while (true) {
                        //当前线程处于阻塞状态，异常必须捕捉处理，无法往外抛出
                        TimeUnit.SECONDS.sleep(2);
                    }
                } catch (InterruptedException e) {
                    System.out.println("Interruted When Sleep");
                    boolean interrupt = this.isInterrupted();
                    //中断状态被复位
                    System.out.println("interrupt:"+interrupt);
                }
            }
        };
        t1.start();
        TimeUnit.SECONDS.sleep(2);
        //中断处于阻塞状态的线程
        t1.interrupt();

        /**
         * 输出结果:
           Interruted When Sleep
           interrupt:false
         */
    }
}

如上述代码所示，我们创建一个线程，并在线程中调用了sleep方法从而使用线程进入阻塞状态，启动线程后，调用线程实例对象的interrupt方法中断阻塞异常，并抛出InterruptedException异常，此时中断状态也将被复位。这里有些人可能会诧异，为什么不用Thread.sleep(2000);而是用TimeUnit.SECONDS.sleep(2);其实原因很简单，前者使用时并没有明确的单位说明，而后者非常明确表达秒的单位，事实上后者的内部实现最终还是调用了Thread.sleep(2000);，但为了编写的代码语义更清晰，建议使用TimeUnit.SECONDS.sleep(2);的方式，注意TimeUnit是个枚举类型。除了阻塞中断的情景，我们还可能会遇到处于运行期且非阻塞的状态的线程，这种情况下，直接调用Thread.interrupt()中断线程是不会得到任响应的，如下代码，将无法中断非阻塞状态下的线程：

public class InterruputThread {
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(){
            @Override
            public void run(){
                while(true){
                    System.out.println("未被中断");
                }
            }
        };
        t1.start();
        TimeUnit.SECONDS.sleep(2);
        t1.interrupt();

        /**
         * 输出结果(无限执行):
             未被中断
             未被中断
             未被中断
             ......
         */
    }
}

虽然我们调用了interrupt方法，但线程t1并未被中断，因为处于非阻塞状态的线程需要我们手动进行中断检测并结束程序，改进后代码如下：

public class InterruputThread {
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(){
            @Override
            public void run(){
                while(true){
                    //判断当前线程是否被中断
                    if (this.isInterrupted()){
                        System.out.println("线程中断");
                        break;
                    }
                }

                System.out.println("已跳出循环,线程中断!");
            }
        };
        t1.start();
        TimeUnit.SECONDS.sleep(2);
        t1.interrupt();

        /**
         * 输出结果:
            线程中断
            已跳出循环,线程中断!
         */
    }
}

是的，我们在代码中使用了实例方法isInterrupted判断线程是否已被中断，如果被中断将跳出循环以此结束线程,注意非阻塞状态调用interrupt()并不会导致中断状态重置。综合所述，可以简单总结一下中断两种情况，一种是当线程处于阻塞状态或者试图执行一个阻塞操作时，我们可以使用实例方法interrupt()进行线程中断，执行中断操作后将会抛出interruptException异常(该异常必须捕捉无法向外抛出)并将中断状态复位，另外一种是当线程处于运行状态时，我们也可调用实例方法interrupt()进行线程中断，但同时必须手动判断中断状态，并编写中断线程的代码(其实就是结束run方法体的代码)。有时我们在编码时可能需要兼顾以上两种情况，那么就可以如下编写：

public void run(){
    try {
    //判断当前线程是否已中断,注意interrupted方法是静态的,执行后会对中断状态进行复位
    while (!Thread.interrupted()) {
        TimeUnit.SECONDS.sleep(2);
    }
    } catch (InterruptedException e) {

    }
}

6.2 中断与synchronized

事实上线程的中断操作对于正在等待获取的锁对象的synchronized方法或者代码块并不起作用，也就是对于synchronized来说，如果一个线程在等待锁，那么结果只有两种，要么它获得这把锁继续执行，要么它就保存等待，即使调用中断线程的方法，也不会生效。演示代码如下

public class SynchronizedBlocked implements Runnable {

    /**
     * 在构造器中创建新线程并启动获取对象锁
     */
    public SynchronizedBlocked() {
        //该线程已持有当前实例锁
        new Thread() {
            public void run() {
                blockedSync(); // Lock acquired by this thread
            }
        }.start();
    }

    @Override
    public void run() {
        //判断当前线程是否已中断,注意interrupted方法是静态的,执行后会对中断状态进行复位
        while (true) {
            if (Thread.interrupted()) {
                System.out.println("中断线程!!");
                break;
            } else {
                blockedSync();
            }
        }


    }

    public synchronized void blockedSync() {
        System.out.println("Trying to call blockedSync()");
        while(true); // Never releases lock
    }

    public static void main(String[] args) throws InterruptedException {
        SynchronizedBlocked sync = new SynchronizedBlocked();
        Thread t = new Thread(sync);
        //启动后调用blockedSync()方法,无法获取当前实例锁处于等待状态
        t.start();
        TimeUnit.SECONDS.sleep(1);
        //中断线程,无法生效
        t.interrupt();

    }

}
			/**   测试结果
			Trying to call blockedSync()
			*/

我们在SynchronizedBlocked构造函数中创建一个新线程并启动获取调用blockedSync()获取到当前实例锁，由于SynchronizedBlocked自身也是线程，启动后在其run方法中也调用了blockedSync()，但由于对象锁被其他线程占用，导致t线程只能等到锁，此时我们调用了t.interrupt();但并不能中断线程。

6.3 等待唤醒机制与synchronized

所谓等待唤醒机制本篇主要指的是notify/notifyAll和wait方法，在使用这3个方法时，必须处于synchronized代码块或者synchronized方法中，否则就会抛出IllegalMonitorStateException异常，这是因为调用这几个方法前必须拿到当前对象的监视器monitor对象，也就是说notify/notifyAll和wait方法依赖于monitor对象，在前面的分析中，我们知道monitor 存在于对象头的Mark Word 中(存储monitor引用指针)，而synchronized关键字可以获取 monitor ，这也就是为什么notify/notifyAll和wait方法必须在synchronized代码块或者synchronized方法调用的原因。

synchronized (obj) {
       obj.wait();
       obj.notify();
       obj.notifyAll();         
 }

需要特别理解的一点是，与sleep方法不同的是wait方法调用完成后，线程将被暂停，但wait方法将会释放当前持有的监视器锁(monitor)，直到有线程调用notify/notifyAll方法后方能继续执行，而sleep方法只让线程休眠并不释放锁。同时notify/notifyAll方法调用后，并不会马上释放监视器锁，而是在相应的synchronized(){}/synchronized方法执行结束后才自动释放锁。

qq_39093474

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Java并发之synchronized实现原理

1. synchronized三种使用方式线程安全是并发编程的重点，如果我们出现安全问题将会导致严重的生产问题（比如秒杀时多卖了一台手机）。并发编程中造成线程安全的诱因主要有两点：一是存在共享资源（也称为临界资源）。二是二级三级目录......
复制链接

扫一扫