jdk源码剖析三：锁Synchronized

---

一、Synchronized作用

（1）确保线程互斥的访问同步代码

（2）保证共享变量的修改能够及时可见

（3）有效解决重排序问题。（Synchronized同步中的代码JVM不会轻易优化重排序）

二、Synchronized常见用法分析

1.修饰普通方法

package lock;

/**
 * 
 * @ClassName:SynchronizedDemo
 * @Description:测试synchronized
 * @author diandian.zhang
 * @date 2017年4月1日下午7:02:34
 */
public class SynchronizedDemo {

    public synchronized void method1(){
        System.out.println("进入方法1");
        try {
            System.out.println("方法1执行");
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("方法1 end");
    }
    
    public synchronized void method2(){
        System.out.println("进入方法2");
        try {
            System.out.println("方法2执行");
            Thread.sleep(000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("方法2 end");
    }
        
    public static void main(String[] args) {
        SynchronizedDemo demo = new SynchronizedDemo();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.method1();
            }
        }).start();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.method2();
            }
        }).start();
    }
}

结果：

进入方法1
方法1执行
方法1 end
进入方法2
方法2执行
方法2 end

可见：修饰普通方法，线程2需要等待线程1的method1执行完成才能开始执行method2方法，方法级别串行执行。

2.修饰静态方法

package lock;

/**
 * 
 * @ClassName:SynchronizedDemo2
 * @Description:修饰静态方法
 * @author diandian.zhang
 * @date 2017年4月5日上午10:48:56
 */
public class SynchronizedDemo2 {

    public static synchronized void method1(){
        System.out.println("进入方法1");
        try {
            System.out.println("方法1执行");
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("方法1 end");
    }
    
    public static synchronized void method2(){
        System.out.println("进入方法2");
        try {
            System.out.println("方法2执行");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("方法2 end");
    }
        
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                SynchronizedDemo2.method1();
            }
        }).start();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                SynchronizedDemo2.method2();
            }
        }).start();
    }
}

运行结果：

进入方法1
方法1执行
进入方法2
方法1 end
方法2执行
方法2 end

可见：修饰静态方法，本质是对类的同步，任何实例调用方法，都类级别串行（每个实例不一定串行）执行。

3.修饰代码块

package lock;

/**
 * 
 * @ClassName:SynchronizedDemo3
 * @Description:Synchronized修饰代码块
 * @author diandian.zhang
 * @date 2017年4月5日上午10:49:50
 */
public class SynchronizedDemo3 {

    public void method1(){
        System.out.println("进入方法1");
        try {
            synchronized (this) {
                System.out.println("方法1执行");
                Thread.sleep(3000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("方法1 end");
    }
    
    public  void method2(){
        System.out.println("进入方法2");
        try {
            synchronized (this) {
                System.out.println("方法2执行");
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("方法2 end");
    }
        
    public static void main(String[] args) {
        SynchronizedDemo3 demo = new SynchronizedDemo3();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.method1();
            }
        }).start();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.method2();
            }
        }).start();
    }
}

运行结果：

进入方法1
方法1执行
进入方法2
方法1 end
方法2执行
方法2 end

可见，修饰代码块，只锁住代码块的执行顺序。代码块级别串行。（例如上面的方法1和方法2没能串行，因为锁住的是同一个对象，但是同步代码块只包住了方法中的一部分）

三、Synchronized 原理

实际上，JVM只区分两种不同用法 1.修饰代码块 2.修饰方法。什么，你不信？好吧，上SE8规范：http://docs.oracle.com/javase/specs/jvms/se8/html/jvms-3.html#jvms-3.14

 

上图中，红框框中说明了，1.monitorenter+monitorexit（上图中的onlyMe方法中同步代码块） 2.修饰方法

 这一切都是规范说的，下面自测一下吧~

 下面，我们通过JDK自带工具反编译，查看包含java字节码的指令。

3.1 synchronized修饰代码块

java源码如下：

public class SynchronizedDemo {
    public void method (){
        synchronized (this) {
            System.out.println("method 1 start!!!!");
        }
    }
}

javac -encoding utf-8 SynchronizedDemo.java 编译生成class 后，javap -c 反编译一下，看指令：

 这里着重分析2个monitorenter、monitorexit这两个指令。这里以JSE8位为准，查到属于JVM指令集。官网各种API、JVM规范，指令等，传送门：http://docs.oracle.com/javase/8/docs/。

1.monitorenter监视器准入指令

 

主要看上图中Description：

每个对象有一个监视器锁（monitor）。当monitor被占用时就会处于锁定状态，线程执行monitorenter指令时尝试获取monitor的所有权，过程如下：

1.如果monitor的进入数为0，则该线程进入monitor，然后将进入数设置为1，该线程即为monitor的所有者。

2.如果线程已经占有该monitor，只是重新进入，则进入monitor的进入数加1.

3.’如果其他线程已经占用了monitor，则该线程进入阻塞状态，直到monitor的进入数为0，再重新尝试获取monitor的所有权。

2.monitorexit监视器释放指令

 主要看上图中Description：

1.执行monitorexit的线程必须是objectref所对应的monitor的所有者。

2.指令执行时，monitor的进入数减1，如果减1后进入数为0，那线程退出monitor，不再是这个monitor的所有者。其他被这个monitor阻塞的线程可以尝试去获取这个 monitor 的所有权。

3.2 synchronized修饰方法

java源码如下：

package lock;

/**
 * 
 * @ClassName:SynchronizedDemo0
 * @Description: Synchronized修饰方法
 * @author diandian.zhang
 * @date 2017年4月5日下午6:18:12
 */
public class SynchronizedDemo0 {
    public synchronized void method (){
        System.out.println("method start!!!!");
    }
}

javap -v 查看class文件，发现method上加了同步标签，本质上还是monitor

3.3 synchronized终极原理C++实现

 

jdk源码剖析二: 对象内存布局、synchronized终极原理

 

四、总结

　　

JDK一直没有放弃synchronized且一直在优化，到目前JDK8依然广泛使用。本文从功能、常见用法、源码实现三方面彻底剖析了synchronized锁。相信读者会有所收获。

 ========附言分割线=====

附：全文参考http://www.cnblogs.com/paddix/p/5367116.html