synchronized详解

在Java中是比较常用的重量级锁，它提供的是一种语言级的支持。 synchronized可以修饰方法和代码块。

synchronized的使用形式

1.使用对象当作锁

它可以把任何对象当作锁。它的实际作用是占有monitor对象，拿到锁的时候会执行执行MONITORENTER这个指令，当代码块执行结束的时候，会释放monitor，执行MONITOREXIT指令。

使用对象当作锁，它可以把任何对象当作锁。拿到锁的时候会执行执行MONITORENTER这个指令，当代码块执行结束的时候，会释放monitor，执行MONITOREXIT指令。
如下代码所示：

public class SynchronizedAction {
    Integer value;

    public void doSomething() {
        synchronized (value) {
            System.out.println("doSomething ...");
        }
    }
    ----------------------------------字节码------------------------------------------
    MONITORENTER
   L0
    LINENUMBER 8 L0
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    LDC "doSomething ..."
    INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/String;)V
   L5
    LINENUMBER 9 L5
    ALOAD 1
    MONITOREXIT

从字节码中可以很方便的看出，执行到doSomething()这个方法的时候，会有monitor对象的执行。

2.给函数加锁

  public synchronized void doSomething() {
        System.out.println("doSomething ...");
    }
----------------------------------字节码------------------------------------------
  public synchronized void doSomething();
    descriptor: ()V
    flags: ACC_PUBLIC, ACC_SYNCHRONIZED

当执行之上代码块的时候，会给方法的flags加上一个标签，它的实际含义就是锁住当前方法的对象。

3.给static方法加锁

   public static synchronized void doSomething() {
        System.out.println("doSomething ...");
    }
----------------------------------字节码------------------------------------------
 public static synchronized void doSomething();
    descriptor: ()V
    flags: ACC_PUBLIC, ACC_STATIC, ACC_SYNCHRONIZED

它的实际意义是给类的加锁，相当于synchronized(SynchronizedAction.class)

在Java的早期版本中，synchronized属于重量级锁，它是依据Mutex Lock实现的，线程之间的切换需要从用户态转换到核心态，开销比较大。在Java6之后，JVM对synchronized进行了很多优化。

自适应自旋锁

首先来说自旋锁，因为在HotSpot虚拟机优化的过程中发现，很多时候，线程同步的代码块执行时间是相当短的。在这段时间如果进行线程切换是相当耗费时间的。在多处理器环境下，完全可以让没获取到锁的线程等待一会不放弃CPU的执行时间，即自旋。在Java6中默认为开启状态。当然代码块执行时间比较长，就该直接挂起等待线程了，在JVM中，可以修改PreBlockSpin来修改超时时间。
在自适应自旋锁中，自旋的时间是不固定的，当前线程如果持有锁，下次竞争在获取锁的概率就大。这时候可以让自旋的次数时间在增长一点。相反，另一个线程获取锁的时间较小，自旋的次数就少一点。

索膨胀

在Jvm中，每个对象都有一个对象头去同步的一些信息。对象头一共有32位。对象头的格式如下图所示：

对象头.png

在Java1.6以后，synchronized做了一些优化，在一些情况下不会占有monitor，锁膨胀的过程如下：

无锁
偏向锁：只有一个线程调用这个对象，不需要获取monitor，它会直接在对象头的偏向锁标志位上置为1。
轻量锁：同一个时刻，只有一个线程在竞争，不需要竞争monitor
重量锁：有多个线程在同时竞争锁，所以必须获取monitor

锁粗化

假设锁需要频繁的加锁解锁，编译器会扩大这个锁。如下例所示：

for(int i =0; i<10000;i++){
    synchronized(this){
        doSomething();
    }
}
/**编译器优化**/

//MONITORENTER
for(int i =0; i<10000;i++){
        doSomething();
}
//MONITOREXIT

锁消除

在某些情况下，编译器会优化锁，进行锁消除:

  public void doSomething() {
        Integer value;
        synchronized(value){
        System.out.println("doSomething ...");
        }   
    }

通过逃逸分析，发现一个对象不可能被其他线程所竞争，就不需要上锁。

对比ReentrantLock

实现机制上不一致，synchronized的实现方式是基于对象头中的Mark Word。ReentrantLock基于的是Unsafe类中的park()方法。
ReentrantLock可以实现更细粒度的控制。
ReentrantLock默认是非公平锁，可以设置为公平锁，但是会引来额外开销不推荐。synchronized是非公平锁。