理解synchronized 和lock

锁是并发编程中经常用到的，本文主要分析下synchronized和lock锁机制的区别。

性能区别

分两种场景来比较，竞争不激烈和竞争激烈情况

竞争不激烈

private static final int THREAD_NUM = 10000;

    private static int test = 0;

    private static ThreadPoolExecutor pool =(ThreadPoolExecutor) Executors.newFixedThreadPool(THREAD_NUM);

    private static ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) throws Exception {

        long startTime = System.currentTimeMillis();
        for (int i = 0; i < THREAD_NUM; i++) {
            pool.execute(TestReentrantLock::testLock);
            pool.execute(TestReentrantLock::testSynchronized);
        }
        pool.shutdown();
        while(pool.getActiveCount()!=0) {}
        long endTime = System.currentTimeMillis();
        System.out.println(endTime - startTime);
    }

    private static void testLock() {

        try {
            lock.lock();
            test++;
        } catch (Exception e) {
            System.out.println(e.getMessage());
        } finally {
            lock.unlock();
        }
    }

    private static synchronized void testSynchronized() {

        test++;
    }

上面代码都是简单的实现，开启10000个线程对一个变量++操作，竞争不激烈，结果显示都在1000左右，不分上下

竞争激烈

public class TestReentrantLock {


    private static final int THREAD_NUM = 10;

    private static double test = 0;

    private static ThreadPoolExecutor pool = (ThreadPoolExecutor) Executors.newFixedThreadPool(THREAD_NUM);

    private static ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) throws Exception {

        long startTime = System.currentTimeMillis();
        for (int i = 0; i < THREAD_NUM; i++) {
            pool.execute(TestReentrantLock::testLock);
            //pool.execute(TestReentrantLock::testSynchronized);
        }
        pool.shutdown();
        while (pool.getActiveCount() != 0) {
        }
        long endTime = System.currentTimeMillis();
        System.out.println(endTime - startTime);
    }

    private static void testLock() {

        for (int i = 0; i < 1000; i++) {
            lock.lock();
            try {
                Thread.sleep(2);
                test++;
            } catch (Exception e) {
                System.out.println(e.getMessage());
            } finally {
                lock.unlock();
            }
        }
    }
    private static void testSynchronized() {

        for (int i = 0; i < 1000; i++) {
            synchronized (lock) {
                try {
                    Thread.sleep(2);
                    test++;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

构建竞争激烈场景，Synchronized性能和lock的性能也差不多
自从synchronized优化之后，总之不管竞争激烈还是不激烈，Synchronized和lock的性能都差不多。

原理介绍

synchronized

JDK1.5中，synchronized是性能低效的。因为这是一个重量级操作，它对性能最大的影响是阻塞的是实现，挂起线程和恢复线程的操作都需要转入内核态中完成，这些操作给系统的并发性带来了很大的压力。到了JDK1.6，对synchronized加入了很多优化措施，有自适应自旋，锁消除，锁粗化，轻量级锁，偏向锁等等。
要想理解synchronized实现，首先要知道java对象的数据结构

java对象数据结构

对象在内存中存储的布局可以分为3块区域：对象头（Header）、实例数据（Instance Data）和对齐填充（Padding）。
其中对象头主要包括两部分：markWord和klass
markWord数据结构如下：
hash： 保存对象的哈希码
age： 保存对象的分代年龄
biased_lock： 偏向锁标识位
lock： 锁状态标识位
JavaThread：* 保存持有偏向锁的线程ID
epoch： 保存偏向时间戳
对象头的另外一部分是klass类型指针，即对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例。
其中锁状态标识位标识了重量级锁、轻量级锁和偏向锁状态，内容如下：

无标题.png

偏向锁

偏向锁，算是竞争锁资源的第一层缓冲，一般指向第一个访问锁线程，如果没有竞争，对象头一直处于偏向锁状态，当只有发生锁资源竞争的时候偏向锁才会撤销，升级成轻量级锁，或者无锁状态

偏向锁获取过程：

第一步，首先访问Mark Word中偏向锁的标识是否设置成1，锁标志位是否为01，确认是否是偏向锁。
第二步，如果为可偏向状态，则测试线程ID是否指向当前线程，如果是，进入步骤5，否则进入步骤3。
第三步，如果线程ID并未指向当前线程，则通过CAS操作竞争锁。如果竞争成功，则将Mark Word中线程ID设置为当前线程ID，然后执行5；如果竞争失败，执行4。
第四步，如果CAS获取偏向锁失败，则表示有竞争。当到达全局安全点时获得偏向锁的线程被挂起，偏向锁升级为轻量级锁，然后被阻塞在安全点的线程继续往下执行同步代码。（撤销偏向锁的时候会导致stop the word）
第五步，执行同步代码。

偏向锁释放过程：

偏向锁只有遇到其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁，线程不会主动去释放偏向锁。偏向锁的撤销，需要等待全局安全点，它会首先暂停拥有偏向锁的线程，判断锁对象是否处于被锁定状态，撤销偏向锁后恢复到未锁定（标志位为“01”）或轻量级锁（标志位为“00”）的状态。

轻量级锁

轻量级锁是偏向锁升级来的，即线程发生竞争，偏向锁会升级成轻量级锁

轻量级锁获取过程：

第一步，在线程进入同步代码块中的时候，虚拟机首先将在当前线程的栈帧中建立一个名为锁记录的空间用于存储对象的Mark Word。
第二步，把对象的Mark Word复制到该锁记录中。
第三步，虚拟机将使用CAS操作尝试将对象的Mark Word中的内容更新为指向锁记录的指针，成功执行步骤4，否则执行步骤5。
第四步，更新成功，那么这个线程就拥有了该对象的锁，并且对象Mark Word的锁标志位设置为“00”，即表示此对象处于轻量级锁定状态。
第五步，更新失败，虚拟机首先会检查对象的Mark Word是否指向当前线程的栈帧，如果是就说明当前线程已经拥有了这个对象的锁，那就可以直接进入同步块。否则说明多个线程竞争锁，轻量级锁升级为重量级锁，锁标志的状态值变为“10”。这里升级重量级锁之前，有一个自旋的过程，自旋成功获取锁就不需要升级到重量级锁，失败升级重量级锁。

轻量级锁释放过程：

轻量级锁在释放锁的时候如果它发现在它持有锁的期间有其他线程来尝试获取锁了，即获取过程中第二步对markword做了修改，两者比对发现不一致，则切换到重量锁。

重量级锁

Mark Word中存储的就是指向重量级锁（互斥量）的指针，后面等待锁的线程也要进入阻塞状态。

总结：
synchronized·就是一个锁升级的过程，偏向锁->轻量级锁（自旋）->重量级锁，不能降级。

Lock实现

Lock是基于AQS实现的，可以参考ReentrantLock源码解析

Lock vs synchronized

而lock的优势在于
1，更自由，不限制于锁加于类，方法上，可以跨方法持有锁
2，支持轮询锁，定时锁，可中断锁等
synchronized的优势在于
1，用法简单直接，原语关键字
2，不会产生gc垃圾。