synchronized的实现原理与应用

利用synchronized实现同步：Java的每个对象都可以作为锁。
对于普通同步方法，锁是当前实例对象。
对于静态同步方法，锁是当前类的Class对象。
对于同步方法块，锁是synchronized括号里配置的对象。

Synchronized在JVM里的实现原理

JVM基于进入和退出Monitor对象来实现方法同步和代码块同步。
代码块同步是使用 monitorenter 和 monitorexit 指令实现。
方法同步虽没有详细说明，但也可以使用这两个指令实现。

monitorenter 指令是在编译后插入到同步代码块的开始位置，而 monitorexit 指令是插入到方法结束处或者异常处。

JVM要保证每个 monitorenter 必须有对应的 monitorexit 与之配对。任何对象都有一个 monitor 与之关联，当一个 monitor 被持有后，它将处于锁定状态。
线程执行到 monitorenter 指令时，将会尝试获取对象所对应的 monitor 的所有权，即尝试获得对象锁。

Java对象头

synchronized用的锁存放在Java对象头。
关于对象头：如果对象是数组类型，则虚拟机用3个字宽（Word）存储对象头；如果对象是非数组类型，则用2字宽存储对象头。

在32位虚拟机中，1字宽=4字节，即32bit

Mark Word：存储对象的hashCode或锁信息
Class Metadata Address：存储到对象类型数据的指针
Array length：数组的长度（如果当前对象是数组）

Java对象头的存储结构：

锁状态	25bit	4bit	1bit 是否偏向锁	2bit 锁标志位
无锁状态	对象的hashcode	对象分代年龄	0	01

Mark Word可能变化为存储以下：

锁状态	25bit	4bit	1bit 是否偏向锁	2bit 锁标志位
轻量级锁	指向栈中所记录的指针			00
重量级锁	指向互斥量（重量级锁）的指针			10
GC标记	空			11
偏向锁	线程ID（23bit） Epoch（2bit）	对象分代年龄	1	01

锁的升级与对比

锁一共有4个状态：无锁、偏向锁、轻量级锁、重量级锁。
锁可以升级，但是不能降级，目的是为了提高获得锁和释放锁的效率。

1.偏向锁

当一个线程访问同步块并获取锁时，会在Mark Word的锁记录里存储锁偏向的线程ID，之后该线程在进入和退出同步块时不需要进行CAS操作来加锁解锁，只需简单测试一下对象头的Mark Word里是否存储着指向当前线程的偏向锁。
如果测试成功，表示线程已经获得了锁。
如果测试失败，则需要测试一下Mark Word中偏向锁的标识是否设置成01（标识偏向锁）：如果没有设置，则使用CAS竞争锁；如果设置了，则尝试使用CAS将对象头的偏向锁指向当前线程。

偏向锁的撤销

当其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁。
偏向锁的撤销，需要等待全局安全点（在这个时间点上没有正在执行的字节码）。
它首先暂停拥有偏向锁的线程，然后检查该线程是否还活着，如果没有，就将对象头设置成无锁状态，如果还活着，则拥有偏向锁的栈就会执行，并遍历偏向对象的锁记录，Mark Word 要么重新偏向于其他线程，要么就恢复到无锁或者标记对象不合适作为偏向锁，最后唤醒暂停的线程。

关闭偏向锁

Java 6 和 Java 7 中偏向锁是默认启动的，但它在应用启动几秒之后才会激活，可以通过设置 JVM 参数来关闭延迟： -XX:BiasedLockingStartupDelay = 0

如果你的应用程序里所有锁通常都处于竞争状态，那么可以通过 JVM 参数关闭偏向锁：
-XX:-UseBiasedLocking = false

设置后，程序默认会进入轻量级锁状态。

轻量级锁

线程在执行同步之前，JVM 会在当前线程栈帧中创建用于存储记录的空间，并将对象头中的 Mark Word 复制到锁记录中，称为 Displaced Mark Word 。线程尝试使用 CAS 将 Mark Work 替换为指向锁记录的指针。如果成功，当前线程获得锁，如果失败，说明其他线程竞争锁，当前线程便尝试使用自旋来获取锁。

轻量级解锁时，会使用原子的 CAS 操作将 Displaced Mark Word 替换回到对象头，若成功，说明没有竞争发生。如果失败，表示当前锁存在竞争，锁就会膨胀成重量级锁。

因为自旋会消耗 CPU，为了避免无用的自旋（比如获得锁的线程被阻塞了），一旦锁升级成重量级锁，就不会再回到轻量级状态。锁处于这种状态下，其他线程试图竞争锁时，都会被阻塞，当该锁被释放之后才会唤醒这些线程，被唤醒的线程就会进行新一轮的竞争。

锁的优缺点对比

偏向锁：加锁解锁不需要额外的消耗，但如果线程间存在锁竞争，将会带来额外的锁撤销消耗。偏向锁适用于只有一个线程访问同步块的场景
轻量级锁：竞争的线程不会被阻塞，提高了程序的响应速度。但如果线程始终得不到锁竞争，使用自旋会消耗 CPU。适用于追求响应时间或者同步块的执行速度非常快的情况。
重量级锁：线程竞争不使用自旋，不会消耗 CPU，但线程会阻塞，相应时间比较慢。适用于追求吞吐量或者同步块执行速度较长的情况。

原子操作的实现原理

原子操作意为「不可中断的一个或一系列操作」

下面是相关术语
Cache line：缓存行。缓存的最小操作单位
CAS：Compare and Swap，比较并交换。CAS操作需要先输入两个数值，一个旧值（期望操作前的值）和一个新值，在操作期间先比较旧值有没有发生变化，若没有发生变化，才交换新值，发生了变化则不交换。
CPU pipeline：CPU流水线。CPU中有 5-6 个不同功能的电路单元组成一条指令处理流水线，然后将 X86 指令分成 5-6 步后再由这些电路单元分别执行，这样就能实现在一个 CPU 时钟周期完成一条指令，提高 CPU 运算速度。
Memory order violation：内存顺序冲突。内存顺序冲突一般是由假共享引起的。假共享是指多个 CPU 同时修改同一个缓存行的不同部分而引起其中一个 CPU 的操作无效，出现这种情况的时候，CPU必须清空流水线。

处理器提供总线锁定和缓存锁定两个机制来实现多处理器之间的原子操作。

总线锁就是使用处理器提供一个 LOCK # 信号，当处理器在总线上输出此信号时，其他处理器的请求将被阻塞，那么发出信号的处理器就会独占共享内存。

总线锁定把 CPU 和内存之间的通信锁住了，这个期间其他处理器不能操作其他内存地址的数据，所以总线锁定的开销较大，这时候就可以用缓存锁定来进行优化。缓存锁定是指内存区域如果被缓存在处理器的缓存行中，在 Lock 期间被锁定，那么当它执行锁操作回写内存的时候，通过修改内部的内存地址，并允许它的缓存一致性机制来保证操作原子性，该机制阻止同时修改由两个以上处理器缓存的内存区域数据。
注意，有两种情况处理器不能用缓存锁定
第一个情况是：如果被操作数据不能被缓存在处理器内部，或者操作的数据跨多个缓存行的时候，处理器会调用总线锁定。
第二种情况是：有些处理器不支持缓存锁定，比如 Inter 486 和 Pentium 处理器。

Java中可以通过锁和循环 CAS 的方式来实现原子操作。以下代码实现了基于 CAS 线程安全的计数方法 safeCount和一个非线程安全的计数方法 count：

public class Counter {
    private AtomicInteger atomicI = new AtomicInteger(0);
    private int  i = 0;
    public static void main(String[] args) {
        final Counter cas = new Counter();
        List<Thread> ts = ArrayList<Thread>(600);
        long start = System.currentTimeMillis();
        for （int j = 0; j < 100; j++）{
            Thread t = new Thread(new Runnable(){
                @Override
                public void run(){
                    for (int i = 0;i < 10000; i++){
                        cas.count();
                        cas.safeCount();
                    }
                }
            });
            ts.add(t);
        }
        for (Thread t : ts) {
            t.start();
        }
        //等待所有线程执行完成
        for (Thread t : ts){
            try {
                t.join();
            } catch (InterruptedException e){
                e.printStackTrace();
            }
        }
        System.out.printIn(cas.i);
        System.out.printIn(cas.atomicI.get());
        System.out.printIn(System.currentTimeMillis() - start);
    }
/**    使用 CAS 实现线程安全计数器   */
    private void safeCount() {
        for (;;){
            int i = atomicI.get();
            boolean suc = atomicI.compareAndSet(i, ++i);
            if (suc) {
                break;
            }
        }
    }
    /**
     *  非线程安全计数器
     */
    private void count () {
        i++;
    }
}

JDK 从 Java 1.5 开始，并发包中提供了一些类来支持原子操作，如 AtomicBoolean，AtomicInteger，AtomicLong，这些原子包装类还提供了很多有用的工具方法，例如通过原子的方式进行自增和自减。

使用 CAS 实现原子操作有三个问题：
ABA 问题：CAS 操作的时候，检查的是值有没有变化，比如原来是 A，变成 B，又变回 A，那么 CAS 检查的时候就会认为它的值没有变化，实际上却变化过了。解决方式是通过添加版本号，比如刚刚的例子，加上版本号后就会变成 1A -> 2B - >3A。Java 1.5 中的 Atomic 包里提供了一个类 AtomicStampedReference 来解决 ABA 问题。

循环时间长开销大：自旋 CAS 如果长时间不成功，CPU 开销将会非常大。JVM 如果能支持处理器提供的pause指令，效率将会有一定提升。pause指令可以延迟流水线执行指令，还可以避免退出循环时候因内存顺序冲突而导致的流水线清空，从而提高 CPU 效率。

只能保证一个共享变量的原子操作：对多个共享变量操作的时候，循环 CAS 无法保证操作的原子性，这时候可以用锁。不过可以通过把多个共享变量合并成一个共享变量来操作。比如，有两个共享变量 i = 2, j = a，合并一下 ij = 2a，然后再用 CAS 来操作 ij。Java 1.5 提供了 AtomicReference类来保证引用对象的原子性，就可以把多个变量放在一个对象里进行 CAS 操作。

使用锁机制实现原子操作
锁机制保证了只有获得锁的线程才能操作锁定的内存区域。JVM 内部有很多锁，偏向、轻量级和互斥锁。除了偏向锁，JVM 实现锁的方式都用了循环 CAS，即进入同步块时候使用循环 CAS 获取锁，退出时候使用循环 CAS 释放锁。

偏向所锁，轻量级锁都是乐观锁，重量级锁是悲观锁。
一个对象刚开始实例化的时候，没有任何线程来访问它的时候。它是可偏向的，意味着，它现在认为只可能有一个线程来访问它，所以当第一个
线程来访问它的时候，它会偏向这个线程，此时，对象持有偏向锁。偏向第一个线程，这个线程在修改对象头成为偏向锁的时候使用CAS操作，并将
对象头中的ThreadID改成自己的ID，之后再次访问这个对象时，只需要对比ID，不需要再使用CAS在进行操作。
一旦有第二个线程访问这个对象，因为偏向锁不会主动释放，所以第二个线程可以看到对象时偏向状态，这时表明在这个对象上已经存在竞争了，检查原来持有该对象锁的线程是否依然存活，如果挂了，则可以将对象变为无锁状态，然后重新偏向新的线程，如果原来的线程依然存活，则马上执行那个线程的操作栈，检查该对象的使用情况，如果仍然需要持有偏向锁，则偏向锁升级为轻量级锁，（偏向锁就是这个时候升级为轻量级锁的）。如果不存在使用了，则可以将对象回复成无锁状态，然后重新偏向。
轻量级锁认为竞争存在，但是竞争的程度很轻，一般两个线程对于同一个锁的操作都会错开，或者说稍微等待一下（自旋），另一个线程就会释放锁。 但是当自旋超过一定的次数，或者一个线程在持有锁，一个在自旋，又有第三个来访时，轻量级锁膨胀为重量级锁，重量级锁使除了拥有锁的线程以外的线程都阻塞，防止CPU空转。