Java并发编程深入理解之Synchronized的使用及底层原理详解下

一、synchronized锁优化

高效并发是从jdk 5升级到jdk 6后一项重要的改进项，hotspot虚拟机开发团队在这个版本上花费了大量的资源去实现各种锁优化技术，如适应性自旋（adaptive spinning）、锁消除（lock elimination）、锁膨胀（lock coarsening）、轻量级锁（lightweight locking）、偏向锁（biased locking）等，这些技术都是为了在线程之间更高效地共享数据及解决竞争问题，从而提高程序的执行效率。

1、自旋锁与自适应自旋

前面介绍线程时提到了挂起线程和恢复线程的操作都需要转入内核态中完成，频繁的用户态、内核态切换是非常消耗资源的。有时候一个线程获取锁之后很短时间就能执行完毕，为了这段时间去挂起和恢复线程并不值得，可以让后面还未获取锁的线程自己等会一会儿而不让出cpu执行时间，看看持有锁的线程是否很快就会释放锁。为了让线程等待，我们只须让线程执行一个忙循环（自旋），这项技术就是所谓的自旋锁。

自旋锁在jdk 1.4.2中就已经引入，只不过默认是关闭的，可以使用-xx：+usespinning参数来开启，在jdk 6中就已经改为默认开启了。自旋等待不能代替阻塞，且先不说对处理器数量的要求，自旋等待本身虽然避免了线程切换的开销，但它是要占用处理器时间的，所以如果锁被占用的时间很短，自旋等待的效果就会非常好，反之如果锁被占用的时间很长，那么自旋的线程只会白白消耗处理器资源，这就会带来性能的浪费。因此自旋等待的时间必须有一定的限度，如果自旋超过了限定的次数仍然没有成功获得锁，就应当使用传统的方式去挂起线程。自旋次数的默认值是十次，用户也可以使用参数-xx：preblockspin来自行更改。

在jdk 6中对自旋锁的优化，引入了自适应的自旋。自适应意味着自旋的时间不再是固定的了，而是由前一次在同一个锁上的自旋时间及锁的拥有者的状态来决定的。如果在同一个锁对象上，自旋等待刚刚成功获得过锁，并且持有锁的线程正在运行中，那么虚拟机就会认为这次自旋也很有可能再次成功，进而允许自旋等待持续相对更长的时间，比如持续100次忙循环。另一方面，如果对于某个锁，自旋很少成功获得过锁，那在以后要获取这个锁时将有可能直接省略掉自旋过程，以避免浪费处理器资源。

2、锁消除

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

public string concatstring(string s1, string s2, string s3) {
    stringbuffer sb = new stringbuffer();
    sb.append(s1);
    sb.append(s2);
    sb.append(s3);
    return sb.tostring();
}

逃逸分析：

使用逃逸分析，编译器可以对代码做如下优化：

一、同步省略。如果一个对象被发现只能从一个线程被访问到，那么对于这个对象的操作可以不考虑同步。
二、将堆分配转化为栈分配。如果一个对象在子程序中被分配，要使指向该对象的指针永远不会逃逸，对象可能是栈分配的候选，而不是堆分配。
三、分离对象或标量替换。有的对象可能不需要作为一个连续的内存结构存在也可以被访问到，那么对象的部分（或全部）可以不存储在内存，而是存储在cpu寄存器中。

是不是所有的对象和数组都会在堆内存分配空间？不一定。在java代码运行时，通过jvm参数可指定是否开启逃逸分析， xx:+doescapeanalysis ：表示开启逃逸分析 xx:-doescapeanalysis：表示关闭逃逸分析。从jdk 1.7开始已经默认开启逃逸分析，开启之后可以通过参数-xx：+printescapeanalysis来查看分析结果。有了逃逸分析支持之后，用户可以使用参数-xx：+eliminateallocations来开启标量替换，使用+xx：+eliminatelocks来开启同步消除，使用参数-xx：+printeliminateallocations查看标量的替换情况。

通过下面的代码示例演示一下开启逃逸分析后，对象进行栈上分配的情况：运行时通过jps查看程序的进程id，然后通过jmap -histo 进程id查看student对象的数量，可以观察到在关闭逃逸分析的时候对象的数量是50万，而开启逃逸分析后是小于50万的，说明有student对象是在栈上分配的而不是堆上分配的。

public class stackalloctest {
 
    /**
     * 进行两种测试
     * 关闭逃逸分析，同时调大堆空间，避免堆内gc的发生，如果有gc信息将会被打印出来
     * vm运行参数：-xmx4g -xms4g -xx:-doescapeanalysis -xx:+printgcdetails -xx:+heapdumponoutofmemoryerror
     *
     * 开启逃逸分析
     * vm运行参数：-xmx4g -xms4g -xx:+doescapeanalysis -xx:+printgcdetails -xx:+heapdumponoutofmemoryerror
     *
     * 执行main方法后
     * jps 查看进程
     * jmap -histo 进程id
     *
     */
 
    public static void main(string[] args) {
        long start = system.currenttimemillis();
        for (int i = 0; i < 500000; i++) {
            alloc();
        }
        long end = system.currenttimemillis();
        //查看执行时间
        system.out.println("cost-time " + (end - start) + " ms");
        try {
            thread.sleep(100000);
        } catch (interruptedexception e1) {
            e1.printstacktrace();
        }
    }
 
 
    private static student alloc() {
        //jit对编译时会对代码进行 逃逸分析
        //并不是所有对象存放在堆区，有的一部分存在线程栈空间
        student student = new student();
        return student;
    }
 
    static class student {
        private string name;
        private int age;
    }
}

3、锁粗化

原则上，我们在编写代码的时候，总是推荐将同步块的作用范围限制得尽量小。大多数情况下，上面的原则都是正确的，但是如果一系列的连续操作都对同一个对象反复加锁和解锁，甚至加锁操作是出现在循环体之中的，那即使没有线程竞争，频繁地进行互斥同步操作也会导致不必要的性能损耗。

上面的代码示例中所示stringbuffer连续的append()方法就属于这类情况。如果虚拟机探测到有这样一串零碎的操作都对同一个对象加锁，将会把加锁同步的范围扩展（粗化）到整个操作序列的外部，以上面代码为例，就是扩展到第一个append()操作之前直至最后一个append()操作之后，这样只需要加锁一次就可以了。

二、对象头内存布局

我们知道synchronized加锁加在对象上，对象是如何记录锁状态的呢？答案是锁状态是被记录在每个对象的对象头（mark word）中，下面我们一起认识一下对象的内存布局。关于对象的内存布局，可以先看下面这张图，图中已经画的很清楚了，可以看到内存中存储的区域可以分为三部分：对象头（header），实例数据（instance data）和对齐填充（padding）。

对象头包括两部分信息，第一部分用于存储对象自身的运行时数据（也称为”markword”），如哈希码（hashcode）、gc分代年龄、锁状态标志、线程持有的锁、偏向线程id、偏向时间戳等，这部分数据的长度在32位和64位的虚拟机（未开启压缩指针）中分别为32bit和64bit。markword被设计成一个非固定的数据结构以便在极小的空间内存储尽量多的信息，它会根据对象的状态复用自己的存储空间。例如，在32位的hotspot虚拟机中，如果对象处于未被锁定的状态下，那么markword的32bit空间中的25bit用于存储对象哈希码，4bit用于存储对象分代年龄，2bit用于存储锁标志位，1bit固定为0，而在其他状态（轻量级锁定、重量级锁定、gc标记、可偏向）下对象的存储内容如下所示：

在openjdk源码中openjdk\hotspot\src\share\vm\oops目录下有个markoop.cpp，里面定义了对象头markwork中的存储内容，有兴趣的可以看一下。

三、synchronized锁的膨胀升级过程

锁的状态总共有四种，无锁状态、偏向锁、轻量级锁和重量级锁。随着锁的竞争，锁可以从偏向锁升级到轻量级锁，再升级的重量级锁，但是锁的升级是单向的，也就是说只能从低到高升级，不会出现锁的降级。

1、偏向锁

偏向锁也是jdk 6中引入的一项锁优化措施，它的目的是消除数据在无竞争情况下的同步原语，进一步提高程序的运行性能。偏向锁的意思是这个锁会偏向于第一个获得它的线程，如果在接下来的执行过程中，该锁一直没有被其他的线程获取，则持有偏向锁的线程将永远不需要再进行同步。

假设当前虚拟机启用了偏向锁（启用参数-xx：+usebiased locking，这是自jdk 6起hotspot虚拟机的默认值），那么当锁对象第一次被线程获取的时候，虚拟机将会把对象头中的标志位设置为“01”、把偏向模式设置为“1”，表示进入偏向模式。同时使用cas操作把获取到这个锁的线程的id记录在对象的mark word之中。如果cas操作成功，持有偏向锁的线程以后每次进入这个锁相关的同步块时，虚拟机都可以不再进行任何同步操作（例如加锁、解锁及对mark word的更新操作等）。

一旦出现另外一个线程去尝试获取这个锁的情况，偏向模式就马上宣告结束。根据锁对象目前是否处于被锁定的状态决定是否撤销偏向（偏向模式设置为“0”），撤销后标志位恢复到未锁定（标志位为“01”）或轻量级锁定（标志位为“00”）的状态，后续的同步操作就按照轻量级锁那样去执行。

偏向锁使用了一种等到竞争出现才释放锁的机制，所以当其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁。偏向锁的撤销，需要等待全局安全点（在这个时间上没有正在执行的字节码）。它会首先暂停拥有偏向锁的线程，然后检查持有偏向锁的线程是否活着，如果线程同步块已经执行完，则将对象头设置成无锁状态；如果线程同步块还没执行完，需要将偏向锁升级为轻量级锁。

当对象进入偏向状态的时候，mark word大部分的空间（23个比特）都用于存储持有锁的线程id了，这部分空间占用了原有存储对象哈希码的位置，那原来对象的哈希码怎么办呢？

在java语言里面一个对象如果计算过哈希码，就应该一直保持该值不变（强烈推荐但不强制，因为用户可以重载hashcode()方法按自己的意愿返回哈希码），否则很多依赖对象哈希码的api都可能存在出错风险。而作为绝大多数对象哈希码来源的object::hashcode()方法，返回的是对象的一致性哈希码（identity hash code），这个值是能强制保证不变的，它通过在对象头中存储计算结果来保证第一次计算之后，再次调用该方法取到的哈希码值永远不会再发生改变。因此，当一个对象已经计算过一致性哈希码后，它就再也无法进入偏向锁状态了；而当一个对象当前正处于偏向锁状态，又收到需要计算其一致性哈希码请求（这里说的计算请求应来自于对object::hashcode()或者system::identityhashcode(object)方法的调用，如果重写了对象的hashcode()方法，计算哈希码时并不会产生这里所说的请求）时，它的偏向状态会被立即撤销，并且锁会膨胀为重量级锁。在重量级锁的实现中，对象头指向了重量级锁的位置，代表重量级锁的objectmonitor类里有字段可以记录非加锁状态（标志位为“01”）下的mark word，其中自然可以存储原来的哈希码。

2、轻量级锁

倘若偏向锁失败，虚拟机并不会立即升级为重量级锁，它还会尝试使用一种称为轻量级锁的优化手段(1.6之后加入的)，此时mark word 的结构也变为轻量级锁的结构。轻量级锁能够提升程序性能的依据是“对绝大部分的锁，在整个同步周期内都不存在竞争”，注意这是经验数据。需要了解的是，轻量级锁所适应的场景是线程交替执行同步块的场合，如果存在同一时间访问同一锁的场合，就会导致轻量级锁膨胀为重量级锁。

在代码即将进入同步块的时候，如果此同步对象没有被锁定（锁标志位为“01”状态），虚拟机首先将在当前线程的栈帧中建立一个名为锁记录（lock record）的空间，用于存储锁对象目前的mark word的拷贝（官方为这份拷贝加了一个displaced前缀，即displaced mark word），这时候线程堆栈与对象头的状态如下图所示。

然后，虚拟机将使用cas操作尝试把对象的mark word更新为指向lock record的指针。如果这个更新动作成功了，即代表该线程拥有了这个对象的锁，并且对象mark word的锁标志位（mark word的最后两个比特）将转变为“00”，表示此对象处于轻量级锁定状态。这时候线程堆栈与对象头的状态如下图所示。

如果这个更新操作失败了，那就意味着至少存在一条线程与当前线程竞争获取该对象的锁。虚拟机首先会检查对象的mark word是否指向当前线程的栈帧，如果是，说明当前线程已经拥有了这个对象的锁，那直接进入同步块继续执行就可以了，否则就说明这个锁对象已经被其他线程抢占了。如果出现两条以上的线程争用同一个锁的情况，那轻量级锁就不再有效，必须要膨胀为重量级锁，锁标志的状态值变为“10”，此时mark word中存储的就是指向重量级锁（互斥量）的指针，后面等待锁的线程也必须进入阻塞状态。

上面描述的是轻量级锁的加锁过程，它的解锁过程也同样是通过cas操作来进行的，如果对象的mark word仍然指向线程的锁记录，那就用cas操作把对象当前的mark word和线程中复制的displaced mark word替换回来。假如能够成功替换，那整个同步过程就顺利完成了；如果替换失败，则说明有其他线程尝试过获取该锁，就要在释放锁的同时，唤醒被挂起的线程。

轻量级锁能提升程序同步性能的依据是“对于绝大部分的锁，在整个同步周期内都是不存在竞争的”这一经验法则。如果没有竞争，轻量级锁便通过cas操作成功避免了使用互斥量的开销；但如果确实存在锁竞争，除了互斥量的本身开销外，还额外发生了cas操作的开销。因此在有竞争的情况下，轻量级锁反而会比传统的重量级锁更慢。

3、重量级锁

当锁升级到重量级锁时，就用到了上文提到的objectmonitor（监视器锁）。在hotspot源码的markoop.hpp文件中，可以看到下面这段代码。多个线程访问同步代码块时，相当于去争抢对象监视器修改对象中的锁标识。对象头markword中可以通过monitor（）方法获取objectmonitor的指针，也就是前面以32位虚拟机举例时markword前30位变成了指向objectmonitor的指针。

  bool has_monitor() const {
    return ((value() & monitor_value) != 0);
  }
  objectmonitor* monitor() const {
    assert(has_monitor(), "check");
    // use xor instead of &~ to provide one extra tag-bit check.
    return (objectmonitor*) (value() ^ monitor_value);
  }

4、各种锁的优缺点

锁	优点	缺点	适用场景
偏向锁	加锁和解锁不需要额外的消耗，和执行非同步方法相比仅存在纳秒级的差距	如果线程间存在锁竞争，会带来额外的锁撤销的消耗	适用于只有一个线程访问同步块的场景
轻量级锁	竞争的线程不会阻塞，提高了程序的响应速度	如果始终得不到锁竞争的线程，使用自旋会消耗cpu	追求响应时间，同步块执行速度非常快，多个线程交替执行的场景
重量级锁	线程竞争不适用自旋，不会消耗cpu	线程阻塞，响应时间缓慢	追求吞吐量，同步块执行时间较长，多个线程锁竞争激烈的场景

到此这篇关于java并发编程深入理解之synchronized的使用及底层原理详解下的文章就介绍到这了,更多相关java 并发编程 synchronized内容请搜索www.887551.com以前的文章或继续浏览下面的相关文章希望大家以后多多支持www.887551.com！

黄山市民网：https://www.huangshanshimin.com/