java 锁的实现过程和应用之 synchronized

lianchaozhao

已于 2022-11-17 19:45:53 修改

阅读量666

点赞数

分类专栏： java 工作常用文章标签： java 面试 jvm

于 2020-04-19 22:03:02 首次发布

本文链接：https://blog.csdn.net/weixin_40809627/article/details/105623449

版权

工作常用同时被 2 个专栏收录

19 篇文章 1 订阅

订阅专栏

java

18 篇文章 1 订阅

订阅专栏

一、概述

线程安全是并发编程中的重要关注点点，应该注意到的是，造成线程安全的主要诱因有两点，**一是存在共享数据（也称为临界资源），二是存在多条线程共同操作共享数据。****因此为了解决这个问题，我们可能需要这样一个方案当存在多个线程操作共享数据时，需要保证同一个时刻只有一个线程在操作共享数据。**其他线程必须等到等到该线程处理完数据后再进行（这就时我们平时说的互斥锁需要完成的事）。也就是我们当前正在访问共享数据的线程会加上互斥锁。而其他线程只能处于等待的状态，直到但钱线程处理完毕释放该锁。再java 中，java 中存在关键字synchronized 可以保证在同一时刻，只有一个线程可以执行某个方法或者某个代码块（主要是对方法或者代码块中存在共享数据的操作）。同时Synchronized 可以抱着一个线程的变化（主要是共享数据的变化）被其他线程所看到（保证可见性，完全可以替代volatile 功能）。这点很重要。

二、Synchroinzed 应用方式

Synchroinzed 关键词我们一般可以三种应用方式，
1、用于修改时实例方法：作用于当前实例加锁，进入同步代码前要获得当前实例的锁。
2、用于修饰静态方法：作用于当前类对像加锁，进入同步代码前要获得当前类对象的锁。
3、应用于修饰代码块：作用域指定加锁的对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。

1、synchroinzed 应用于实例方法中

所谓实例对象锁就是用synchronized修饰实例对象的实例方法（但实例不应该是静态方法）
例子：
在这里插入图片描述
总结：上述代码中，我们开启了两个线程操作同一个共享资源的变量i。我们知道在java 中i++这样的操作并不具备原子性，该操作实际上可以分为四部（简单理解为数据先读取值，然后写回一个新值）。在我们不加同步锁的时候。如果第二个线程在第一个线程读取旧值和写回新值期间读取i的域值，那么第二个线程就会与第一个线程一起看到同一个值，并执行相同值的加1操作，导致结果会比我们想要的值要小的效果。因此为了使程序跑出正确的数据。我们选择对于increase方法必须使用synchronized修饰，以便保证线程安全。此时我们注意到synchronized修饰的是实例方法increase，这样的情况侠，当前当前线程的锁便是实例出地对象instance的锁。（注意java中线程同步锁可以是任意对象，从代码执行结果来看确实是正确的。）但是如果我们没有使用synchronized关键字，其不能保证一个线程内i++ 同时执行完了。其最终的结果可能小于200000.
综上:我们了解到了synchronized关键字的作用。当一个线程正在访问一个对象的 synchronized 实例方法，那么其他线程不能访问该对象的其他 synchronized 方法，毕竟一个对象只有一把锁，当一个线程获取了该对象的锁之后，其他线程无法获取该对象的锁，所以无法访问该对象的其他synchronized实例方法，但是其他线程还是可以访问该对象的其他非synchronized方法，当然如果是一个线程A需要访问实例对象obj1 的 synchronized 方法 f1(当前对象锁是obj1)，另一个线程 B 需要访问实例对象 obj2 的 synchronized 方法 f2(当前对象锁是obj2)，这样是允许的，（因为每个对象实例都会存在一把锁，两个实例对象锁不相同，此时两个相处操作的数据也并不是共享的，线程安全是有保障的）。

注意：如果两个线程操作的是共享数据，那么线程安全就有可能无法保证了，如下代码将演示出该现象
（新建了两个对象，存在不同的两把锁，但两个对象中变量是static 静态的，所以两个对象是共享数据了，所以会出现两个线程会出现同时处理共享数据的情况，即使代码中看着是加了锁）

public class AccountingSyncBad implements Runnable{
    static int i=0;
    public synchronized void increase(){
        i++;
    }
    @Override
    public void run() {
        for(int j=0;j<1000000;j++){
            increase();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        //new新实例
        Thread t1=new Thread(new AccountingSyncBad());
        //new新实例
        Thread t2=new Thread(new AccountingSyncBad());
        t1.start();
        t2.start();
        //join含义:当前线程A等待thread线程终止之后才能从thread.join()返回
        t1.join();
        t2.join();
        System.out.println(i);
    }
}

上述代码代码和前面代码例子不同之处在于我们同时创建了两个新实例AccountingSyncBad，然后启动两个不同的线程对共享变量i 进行操作，虽然我们使用synchronized修饰了increase方法，但却new了两个不同的实例对象，这也就意味着存在着两个不同的实例对象锁，因此t1和t2都会进入各自的对象锁，也就是说t1和t2线程使用的是不同的锁，因此线程安全是无法保证的。而我们解决这种困境的方式是将synchronized作用与静态的increase方法，这样的话，对象锁就是当前的类对象，因此无论我们创建多少个实例对象。但对于类对象只有一个，所有在这样的情况侠对象锁就是唯一的。具体实现方式参考下面例子

public class AccountingSyncClass implements Runnable{
    static int i=0;

    /**
     * 作用于静态方法,锁是当前class对象,也就是
     * AccountingSyncClass类对应的class对象
     */
    public static synchronized void increase(){
        i++;
    }

    @Override
    public void run() {
        for(int j=0;j<1000000;j++){
            increase();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        //new新实例
        Thread t1=new Thread(new AccountingSyncClass());
        //new心事了
        Thread t2=new Thread(new AccountingSyncClass());
        //启动线程
        t1.start();t2.start();

        t1.join();t2.join();
        System.out.println(i);
    }
}

2、synchronized作用于静态方法

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

public class AccountingSyncClass implements Runnable{
    static int i=0;

    /**
     * 作用于静态方法,锁是当前class对象,也就是
     * AccountingSyncClass类对应的class对象
     */
    public static synchronized void increase(){
        i++;
    }

    /**
     * 非静态,访问时锁不一样不会发生互斥
     */
    public synchronized void increase4Obj(){
        i++;
    }

    @Override
    public void run() {
        for(int j=0;j<1000000;j++){
            increase();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        //new新实例
        Thread t1=new Thread(new AccountingSyncClass());
        //new心事了
        Thread t2=new Thread(new AccountingSyncClass());
        //启动线程
        t1.start();t2.start();

        t1.join();t2.join();
        System.out.println(i);
    }
}

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

3、synchronized同步代码块
除了使用关键词修饰实例方法和静态方法外，还可以使用同步代码块，在某些情况下。我们编写的方法可能较大，同时锁住一个方法会存在比较耗时情况。这时我们只需要对我们需要进行同步的一小部分代码进行同步加锁。此时我们可以使用同步代码块的方式对需要同步的代码进行包裹，具体使用示例如下。

public class AccountingSync implements Runnable{
    static AccountingSync instance=new AccountingSync();
    static int i=0;
    @Override
    public void run() {
        //省略其他耗时操作....
        //使用同步代码块对变量i进行同步操作,锁对象为instance
        synchronized(instance){
            for(int j=0;j<1000000;j++){
                    i++;
              }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(instance);
        Thread t2=new Thread(instance);
        t1.start();t2.start();
        t1.join();t2.join();
        System.out.println(i);
    }
}

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

synchronized(this){
    for(int j=0;j<1000000;j++){
        i++;
    }
}

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

上面讲了synchronized的三种应用方式，其具体synchronized的底层是怎样实现的那？

三、synchronized底层语义原理分析

synchronized在并发编程中经常使用它的源码是 C++ 实现的。java虚拟机中的同步（Synchronized）是基于进入和退出管程（Monitor）对像实现，无论是显示同步（有明确的moniorenter和monitorexit指令，即同步代码块）还是隐式同步都是如此。在java 语言中同步用的最多的地方可能是被synchronized修饰的同步方法。同步方式并不是由monitorenter 和 monitorexit指令来实现同步的，而是由方法调用指令读取运行时常量池中的方法ACC_SYNCHRONIZED 标志来隐式实现的。

1、java 的对象头
java对象头的设计对我们理解synchronized实现原理非常关键。在JVM中对象内存中的布局分为三块区域：对象头、实例数据和对其填充。其中：
在这里插入图片描述

（1）、实例变量：存放类的属性信息，包括父类的属性信息，如果时数组的实例部分还可以包括数组的长度，这部分内存按照4字节对齐。
（2）、填充数据：由于虚拟机要求对象的起始地址必须时8字节的整数被。填充数据不是必须存在的，仅仅为了字节对齐，这点了解即可。
（3）、对象头由两部分组成 1）Mark Word：存储自身运行时的数据，例如hashCode、GC年龄、锁相关的信息等内容 2）、Klass Pointer ：类型指针指向它的类元数据集的指针。
注意：其中64 位虚拟机 Mark Word 是 64bit 其结构如下
在这里插入图片描述
其中轻量级锁和偏向锁是Java6 对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;// 存储该 monitor 的对象
    _owner        = NULL;// 指向拥有该 monitor 的线程
    _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，同时该线程进入WaitSe t集合中等待被唤醒。若当前线程执行完毕也将释放monitor(锁)并复位变量的值，以便其他线程进入获取monitor(锁)。如下图所示
在这里插入图片描述
由此看来，monitor 对象存在于每个Java对象的对象头中（存储指针的指向），synchronized锁便可以通过这种方式获取锁的，也是为啥Java中任意对象可以作为锁的原因，同时也是notify/notifyAll/wait等方法存在于顶级对象Object中的原因(关于这点稍后还会进行分析)。ok 理解了上面的信息，接下来我们将进一步分析synchronized在字节码层面的具体语义实现。

synchronized 代码底层原理
我们可以定义一个synchronized修改时的同步代码块，在代码中操作共享变量i 代码示例如下

public class SyncCodeBlock {
       public int i；
       public void syncTask(){
       //同步代码库
       synchronized(this){
       i++
       }
       }
}

编译上述代码并使用javap反编译后得到字节码如下

public class com.zejian.concurrencys.SyncCodeBlock
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
  //........省略常量池中数据
  //构造函数
  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(关于重入新稍后分析)，如果其他线程已经拥有objectref的monitor的所有全，那当前线程将被阻塞，直到正在执行线程执行完毕，即monitorexit指令被执行，执行线程将释放monitor(锁)并设置计数器值为0，其他线程将有机会持有monitor 指令，（其中需要注意的时编译器将无法确保无论方法通过何种方式完成）方法中调用过的每条monitorenter方法都有执行其对应 monitorexit 指令，而无论这个方法是正常结束还是异常结束。为了保证在方法异常完成时 monitorenter 和 monitorexit 指令依然可以正确配对执行，编译器会自动产生一个异常处理器，这个异常处理器声明可处理所有的异常，它的目的就是用来执行 monitorexit 指令。从字节码中也可以看出多了一个monitorexit指令，它就是异常结束时被执行的释放monitor 的指令。

由上可知方法级的同步是隐式的，即无需通过字节码指令来控制的，它事项方法调用和返回操作之中。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锁的优化。（参考：https://blog.csdn.net/javazejian/article/details/72828483）

实际例子

Class GeoPointToAOI


private volatile static AoiIndex real_index = null;
 private void syncInitIndexPointData(String dirString) throws Exception {
        if (real_index == null ) {
            log.info("before initIndexPointData times=" + System.currentTimeMillis() + "real_index == null=" + (real_index == null) + "finished=" + finished);
            synchronized (GeoPointToAOI.class) {
                if (null == real_index) {
                    initIndexPointData(dirString);
                }

            }

            log.info("aoiIndex.size=" + real_index.size());
        }

    }

lianchaozhao

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
java 锁的实现过程和应用之 synchronized

所谓AQS，指的是AbstractQueuedSynchronizer，它提供了一种实现阻塞锁和一系列依赖FIFO等待队列的同步器的框架，ReentrantLock、Semaphore、CountDownLatch、CyclicBarrier等并发类均是基于AQS来实现的，具体用法是通过继承AQS实现其模板方法，然后将子类作为同步组件的内部类。AbstractQueuedSynchronizer...
复制链接

扫一扫