synchronized与static synchronized 的差别、synchronized在JVM底层的实现原理及Java多线程锁理解

本Blog分为例如以下部分：

第一部分：synchronized与static synchronized 的差别

第一部分：synchronized与static synchronized的差别

1、synchronized与static synchronized 的差别
      synchronized是对类的当前实例进行加锁，防止其它线程同一时候訪问该类的该实例的全部synchronized块。注意这里是“类的当前实例”。类的两个不同实例就没有这样的约束了。

那么static synchronized恰好就是要控制类的全部实例的訪问了，static synchronized是限制线程同一时候訪问jvm中该类的全部实例同一时候訪问相应的代码快。实际上，在类中某方法或某代码块中有 synchronized，那么在生成一个该类实例后，该类也就有一个监视快，放置线程并发訪问该实例synchronized保护快。而static synchronized则是全部该类的实例公用一个监视快了。也就是两个的差别了,也就是synchronized相当于this.synchronized。而staticsynchronized相当于Something.synchronized.
      pulbic class Something(){
         public synchronized void isSyncA(){}
         public synchronized voidisSyncB(){}
         public static synchronizedvoid cSyncA(){}
         public static synchronizedvoid cSyncB(){}
     }

注解：该列子来自一个日本作者-结成浩的《java多线程设计模式》
    那么，假如有Something类的两个实例a与b，那么下列组方法何以被1个以上线程同一时候訪问呢
   a.   x.isSyncA()与x.isSyncB() 
   b.   x.isSyncA()与y.isSyncA()
   c.   x.cSyncA()与y.cSyncB()
   d.   x.isSyncA()与Something.cSyncA()
    这里。非常清楚的能够推断：
   a，都是对同一个实例的synchronized域訪问，因此不能被同一时候訪问
   b，是针对不同实例的，因此能够同一时候被訪问
   c，由于是staticsynchronized，所以不同实例之间仍然会被限制,相当于Something.isSyncA()与   Something.isSyncB()了，因此不能被同一时候訪问。
     那么，第d呢?。书上的 答案是能够被同一时候訪问的，答案理由是synchronzied的是实例方法与synchronzied的类方法因为锁定（lock）不同的原因。
     个人分析也就是synchronized 与static synchronized 相当于两帮派，各自管各自，相互之间就无约束了，能够被同一时候訪问。后面一部分将具体分析synchronzied是怎么样实现的。

结论：

A: synchronized static是某个类的范围。synchronized static cSync{}防止多个线程同一时候訪问这个类中的synchronized static 方法。它能够对类的全部对象实例起作用。

B: synchronized 是某实例的范围。synchronized isSync(){}防止多个线程同一时候訪问这个实例中的synchronized 方法。

2、synchronized方法与synchronized代码快的差别
      synchronizedmethods(){} 与synchronized（this）{}之间没有什么差别。仅仅是 synchronized methods(){} 便于阅读理解。而synchronized（this）{}能够更精确的控制冲突限制訪问区域，有时候表现更高效率。

3、synchronizedkeyword是不能继承的
     也就是说。基类的方法synchronized f(){} 在继承类中并不自己主动是synchronized f(){}，而是变成了f(){}。

继承类须要你显式的指定它的某个方法为synchronized方法；

4、从源代码具体理解synchronizedkeyword（參考Observable类源代码）

Java中的Observer模式，看了当中的Observable类的源代码。发现里面差点儿所有的方法都用了synchronizedkeyword（不是所有）。当中个别用了synchronized(this){}的区块

參考网址：

http://www.learndiary.com/archives/diaries/2910.htm

http://www.cnblogs.com/shipengzhi/articles/2223100.html

第二部分：JVM底层又是怎样实现synchronized的

眼下在Java中存在两种锁机制：synchronized和Lock。Lock接口及事实上现类是JDK5添加的内容，其作者是大名鼎鼎的并发专家DougLea。本文并不比較synchronized与Lock孰优孰劣，仅仅是介绍二者的实现原理。

数据同步须要依赖锁，那锁的同步又依赖谁？synchronized给出的答案是在软件层面依赖JVM，而Lock给出的方案是在硬件层面依赖特殊的CPU指令。大家可能会进一步追问：JVM底层又是怎样实现synchronized的？

本文所指说的JVM是指Hotspot的6u23版本号。以下首先介绍synchronized的实现：

synrhronizedkeyword简洁、清晰、语义明白，因此即使有了Lock接口。使用的还是很广泛。其应用层的语义是能够把不论什么一个非null对象作为"锁"，当synchronized作用在方法上时。锁住的便是对象实例（this）；当作用在静态方法时锁住的便是对象相应的Class实例，由于 Class数据存在于永久带，因此静态方法锁相当于该类的一个全局锁；当synchronized作用于某一个对象实例时，锁住的便是相应的代码块。

在HotSpot JVM实现中，锁有个专门的名字：对象监视器。

1. 线程状态及状态转换

当多个线程同一时候请求某个对象监视器时。对象监视器会设置几种状态用来区分请求的线程：

ContentionList：全部请求锁的线程将被首先放置到该竞争队列

EntryList：ContentionList中那些有资格成为候选人的线程被移到Entry List

WaitSet：那些调用wait方法被堵塞的线程被放置到Wait Set

OnDeck：不论什么时刻最多仅仅能有一个线程正在竞争锁，该线程称为OnDeck

Owner：获得锁的线程称为Owner

!Owner：释放锁的线程

下图反映了这个状态转换关系：

新请求锁的线程将首先被增加到ConetentionList中，当某个拥有锁的线程（Owner状态）调用unlock之后。假设发现 EntryList为空则从ContentionList中移动线程到EntryList。以下说明下ContentionList和EntryList 的实现方式：

ContentionList并非一个真正的Queue。而仅仅是一个虚拟队列。原因在于ContentionList是由Node及其next指 针逻辑构成。并不存在一个Queue的数据结构。ContentionList是一个后进先出（LIFO）的队列。每次新增加Node时都会在队头进行， 通过CAS改变第一个节点的的指针为新增节点，同一时候设置新增节点的next指向兴许节点。而取得操作则发生在队尾。

显然。该结构事实上是个Lock- Free的队列。

由于仅仅有Owner线程才干从队尾取元素，也即线程出列操作无争用，当然也就避免了CAS的ABA问题。

1.2 EntryList

EntryList与ContentionList逻辑上同属等待队列，ContentionList会被线程并发訪问。为了减少对 ContentionList队尾的争用。而建立EntryList。

Owner线程在unlock时会从ContentionList中迁移线程到 EntryList，并会指定EntryList中的某个线程（一般为Head）为Ready（OnDeck）线程。Owner线程并非把锁传递给 OnDeck线程。仅仅是把竞争锁的权利交给OnDeck，OnDeck线程须要又一次竞争锁。这样做尽管牺牲了一定的公平性。但极大的提高了总体吞吐量。在 Hotspot中把OnDeck的选择行为称之为“竞争切换”。

OnDeck线程获得锁后即变为owner线程，无法获得锁则会依旧留在EntryList中。考虑到公平性。在EntryList中的位置不 发生变化（依旧在队头）。假设Owner线程被wait方法堵塞，则转移到WaitSet队列；假设在某个时刻被notify/notifyAll唤醒。 则再次转移到EntryList。

2. 自旋锁

那些处于ContetionList、EntryList、WaitSet中的线程均处于堵塞状态，堵塞操作由操作系统完毕（在Linxu下通 过pthread_mutex_lock函数）。线程被堵塞后便进入内核（Linux）调度状态，这个会导致系统在用户态与内核态之间来回切换，严重影响 锁的性能

缓解上述问题的办法便是自旋，其原理是：当发生争用时，若Owner线程能在非常短的时间内释放锁，则那些正在争用线程能够略微等一等（自旋）。 在Owner线程释放锁后，争用线程可能会马上得到锁，从而避免了系统堵塞。但Owner执行的时间可能会超出了临界值。争用线程自旋一段时间后还是无法 获得锁，这时争用线程则会停止自旋进入堵塞状态（后退）。基本思路就是自旋，不成功再堵塞，尽量减少堵塞的可能性，这对那些执行时间非常短的代码块来说有非 常重要的性能提高。自旋锁有个更贴切的名字：自旋-指数后退锁，也即复合锁。非常显然，自旋在多处理器上才有意义。

还有个问题是，线程自旋时做些啥？事实上啥都不做，能够运行几次for循环，能够运行几条空的汇编指令，目的是占着CPU不放。等待获取锁的机 会。所以说。自旋是把双刃剑，假设旋的时间过长会影响总体性能。时间过短又达不到延迟堵塞的目的。显然。自旋的周期选择显得非常重要，但这与操作系统、硬 件体系、系统的负载等诸多场景相关，非常难选择，假设选择不当。不但性能得不到提高，可能还会下降，因此大家普遍觉得自旋锁不具有扩展性。

自旋优化策略

对自旋锁周期的选择上，HotSpot觉得最佳时间应是一个线程上下文切换的时间，但眼下并没有做到。经过调查，眼下仅仅是通过汇编暂停了几个CPU周期，除了自旋周期选择。HotSpot还进行更多的自旋优化策略，详细例如以下：

假设平均负载小于CPUs则一直自旋

假设有超过(CPUs/2)个线程正在自旋，则后来线程直接堵塞

假设正在自旋的线程发现Owner发生了变化则延迟自旋时间（自旋计数）或进入堵塞

假设CPU处于节电模式则停止自旋

自旋时间的最坏情况是CPU的存储延迟（CPU A存储了一个数据，到CPU B得知这个数据直接的时间差）

自旋时会适当放弃线程优先级之间的差异

那synchronized实现何时使用了自旋锁？答案是在线程进入ContentionList时，也即第一步操作前。

线程在进入等待队列时 首先进行自旋尝试获得锁，假设不成功再进入等待队列。这对那些已经在等待队列中的线程来说。略微显得不公平。另一个不公平的地方是自旋线程可能会抢占了 Ready线程的锁。自旋锁由每一个监视对象维护，每一个监视对象一个。

3. JVM1.6偏向锁

在JVM1.6中引入了偏向锁，偏向锁主要解决无竞争下的锁性能问题，首先我们看下无竞争下锁存在什么问题：

如今差点儿全部的锁都是可重入的，也即已经获得锁的线程能够多次锁住/解锁监视对象。依照之前的HotSpot设计，每次加锁/解锁都会涉及到一些CAS操 作（比方对等待队列的CAS操作），CAS操作会延迟本地调用，因此偏向锁的想法是一旦线程第一次获得了监视对象，之后让监视对象“偏向”这个 线程，之后的多次调用则能够避免CAS操作，说白了就是置个变量，假设发现为true则无需再走各种加锁/解锁流程。但还有非常多概念须要解释、非常多引入的 问题须要解决：

3.1 CAS及SMP架构

CAS为什么会引入本地延迟？这要从SMP（对称多处理器）架构说起，下图大概表明了SMP的结构：

其意思是全部的CPU会共享一条系统总线（BUS），靠此总线连接主存。每一个核都有自己的一级缓存，各核相对于BUS对称分布，因此这样的结构称为“对称多处理器”。

而CAS的全称为Compare-And-Swap，是一条CPU的原子指令，其作用是让CPU比較后原子地更新某个位置的值，经过调查发现， 事实上现方式是基于硬件平台的汇编指令。就是说CAS是靠硬件实现的。JVM仅仅是封装了汇编调用。那些AtomicInteger类便是使用了这些封装后的 接口。

Core1和Core2可能会同一时候把主存中某个位置的值Load到自己的L1 Cache中，当Core1在自己的L1 Cache中改动这个位置的值时，会通过总线，使Core2中L1 Cache相应的值“失效”。而Core2一旦发现自己L1 Cache中的值失效（称为Cache命中缺失）则会通过总线从内存中载入该地址最新的值，大家通过总线的来回通信称为“Cache一致性流量”。由于总 线被设计为固定的“通信能力”。假设Cache一致性流量过大。总线将成为瓶颈。而当Core1和Core2中的值再次一致时，称为“Cache一致 性”，从这个层面来说。锁设计的终极目标便是降低Cache一致性流量。

而CAS恰好会导致Cache一致性流量。假设有非常多线程都共享同一个对象，当某个Core CAS成功时必定会引起总线风暴，这就是所谓的本地延迟，本质上偏向锁就是为了消除CAS，减少Cache一致性流量。

Cache一致性：

上面提到Cache一致性，事实上是有协议支持的。如今通用的协议是MESI（最早由Intel開始支持），详细參考：http://en.wikipedia.org/wiki/MESI_protocol。以后会细致解说这部分。

Cache一致性流量的例外情况：

事实上也不是全部的CAS都会导致总线风暴，这跟Cache一致性协议有关，详细參考：http://blogs.oracle.com/dave/entry/biased_locking_in_hotspot

NUMA(Non Uniform Memory Access Achitecture）架构：

与SMP相应还有非对称多处理器架构，如今主要应用在一些高端处理器上。主要特点是没有总线，没有公用主存，每一个Core有自己的内存，针对这样的结构此处不做讨论。

3.2 偏向解除

偏向锁引入的一个重要问题是。在多争用的场景下，假设另外一个线程争用偏向对象，拥有者须要释放偏向锁，而释放的过程会带来一些性能开销，但整体说来偏向锁带来的优点还是大于CAS代价的。

4. 总结

关于锁。JVM中还引入了一些其它技术比方锁膨胀等。这些与自旋锁、偏向锁相比影响不是非常大。这里就不做介绍。

通过上面的介绍能够看出，synchronized的底层实现主要依靠Lock-Free的队列，基本思路是自旋后堵塞，竞争切换后继续竞争锁。略微牺牲了公平性，但获得了高吞吐量。

參考文献：http://www.open-open.com/lib/view/open1352431526366.html

第三部分：Java多线程锁，源码剖析

多线程的同步依靠的是锁机制，java中可通过synchronizedkeyword锁锁住共享资源以实现异步多线程的达到同步。

总结起来。要达到同步。我们要做的就是构造各线程间的共享资源。当中的共享资源能够对象，也能够是方法。

package algorithms.com.guan.zoo.stackTest;

public class LockDemo {
	public static void main(String[] args) {
		MyRunnerVarLock runnerVarLock = new MyRunnerVarLock(new Integer(0));
		MyRunnerFuncLock runnerFuncLock = new MyRunnerFuncLock();
		MyRunnerNoLock runnerNoLock = new MyRunnerNoLock(); 
		
		// 对共享对象进行加锁，线程会依次打印0-99的数，每一次执行的结果都一样
		for(int i = 0; i < 10; i++) {
			Thread thread = new Thread(runnerVarLock);
			thread.start();
		}
		
		// 对共享函数进行加锁。线程会依次打印0-99的数，每一次执行的结果都一样
		for(int i = 0; i < 10; i++) {
			Thread thread = new Thread(runnerFuncLock);
			thread.start();
		}
		
		// 未加锁，会由于线程调用的时序不同而发生变化。每一次执行的结果不一定同样
		for(int i = 0; i < 10; i++) {
			Thread thread = new Thread(runnerNoLock);
			thread.start();
		}
	}
}

// 对共享对象进行加锁
class MyRunnerVarLock implements Runnable {
	private Object lock;

	public MyRunnerVarLock(Object lock) {
		this.lock = lock;
	}

	public void run() {
		synchronized (lock) {
			for (int i = 0; i < 100; i++) {
				System.out.println("Lock: " + i);
			}
		}
	}
}

// 对共享函数进行加锁
class MyRunnerFuncLock implements Runnable {
	public synchronized void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println("Func lock: " + i);
		}
	}
}

// 没有加锁
class MyRunnerNoLock implements Runnable {
	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println("No lock: " + i);
		}
	}
}

Lock: 0
Lock: 1
Lock: 2
Lock: 3
Lock: 4
Lock: 5
Lock: 6
Lock: 7
Lock: 8
Lock: 9
Lock: 10
Lock: 11
Lock: 0
Lock: 1
Lock: 2
Lock: 3
Lock: 4
Lock: 5
Lock: 6
Lock: 7
Lock: 8
Lock: 9
Lock: 10
Lock: 11
Lock: 0
Lock: 1
Lock: 2
Lock: 3
Lock: 4
Lock: 5
Lock: 6
Lock: 7
Lock: 8
Lock: 9
Lock: 10
Lock: 11
Lock: 0
Lock: 1
Lock: 2
Lock: 3
Lock: 4
Lock: 5
Lock: 6
Lock: 7
Lock: 8
Lock: 9
Lock: 10
Lock: 11
Func lock: 0
Func lock: 1
Func lock: 2
Func lock: 3
Func lock: 4
Func lock: 5
Func lock: 6
Lock: 0
Lock: 1
Lock: 2
Lock: 3
Lock: 4
Lock: 5
Func lock: 7
Func lock: 8
Func lock: 9
Func lock: 10
Func lock: 11
Func lock: 0
Func lock: 1
Func lock: 2
Func lock: 3
Func lock: 4
Func lock: 5
Lock: 6
Lock: 7
Func lock: 6
Func lock: 7
Lock: 8
Lock: 9
Lock: 10
Lock: 11
Func lock: 8
Func lock: 9
Lock: 0
Lock: 1
Lock: 2
Lock: 3
Lock: 4
Lock: 5
Lock: 6
Lock: 7
Lock: 8
Lock: 9
Lock: 10
Lock: 11
Lock: 0
Lock: 1
Lock: 2
No lock: 0
No lock: 0
No lock: 1
No lock: 2
Func lock: 10
Func lock: 11
No lock: 3
No lock: 4
No lock: 5
No lock: 6
No lock: 0
No lock: 1
No lock: 0
No lock: 1
No lock: 2
No lock: 3
Lock: 3
No lock: 0
No lock: 1
No lock: 0
No lock: 0
No lock: 1
No lock: 2
No lock: 0
Lock: 4
No lock: 4
No lock: 0
No lock: 2
No lock: 1
No lock: 7
No lock: 0
Func lock: 0
No lock: 1
No lock: 8
No lock: 2
No lock: 3
No lock: 1
No lock: 5
Lock: 5
No lock: 1
No lock: 2
No lock: 3
No lock: 2
No lock: 1
No lock: 3
No lock: 4
No lock: 3
Lock: 6
No lock: 6
No lock: 2
No lock: 4
No lock: 5
No lock: 3
No lock: 9
No lock: 2
Func lock: 1
No lock: 3
No lock: 10
No lock: 4
No lock: 6
No lock: 3
No lock: 7
Lock: 7
Lock: 8
Lock: 9
Lock: 10
No lock: 4
No lock: 5
No lock: 5
No lock: 4
No lock: 2
No lock: 5
No lock: 6
No lock: 6
No lock: 7
Lock: 11
No lock: 8
No lock: 9
No lock: 4
No lock: 7
No lock: 5
No lock: 11
No lock: 4
Func lock: 2
No lock: 5
No lock: 6
No lock: 8
No lock: 5
No lock: 10
Lock: 0
No lock: 8
No lock: 7
No lock: 6
No lock: 3
No lock: 7
No lock: 8
No lock: 9
No lock: 10
Lock: 1
No lock: 11
No lock: 6
No lock: 9
No lock: 7
No lock: 7
No lock: 6
Func lock: 3
No lock: 7
No lock: 8
No lock: 8
No lock: 10
Lock: 2
No lock: 11
No lock: 9
No lock: 8
No lock: 9
No lock: 4
No lock: 10
No lock: 10
Lock: 3
No lock: 11
No lock: 9
No lock: 9
No lock: 8
Func lock: 4
No lock: 9
No lock: 10
No lock: 10
Lock: 4
No lock: 11
No lock: 11
No lock: 5
No lock: 6
No lock: 7
Lock: 5
No lock: 11
No lock: 11
No lock: 10
No lock: 11
Func lock: 5
Lock: 6
No lock: 8
Lock: 7
Func lock: 6
Lock: 8
No lock: 9
Lock: 9
Func lock: 7
Lock: 10
No lock: 10
No lock: 11
Lock: 11
Func lock: 8
Lock: 0
Func lock: 9
Lock: 1
Func lock: 10
Lock: 2
Func lock: 11
Lock: 3
Func lock: 0
Lock: 4
Func lock: 1
Lock: 5
Func lock: 2
Lock: 6
Func lock: 3
Func lock: 4
Lock: 7
Func lock: 5
Lock: 8
Func lock: 6
Func lock: 7
Lock: 9
Func lock: 8
Lock: 10
Func lock: 9
Lock: 11
Func lock: 10
Lock: 0
Func lock: 11
Lock: 1
Lock: 2
Lock: 3
Lock: 4
Func lock: 0
Func lock: 1
Func lock: 2
Lock: 5
Func lock: 3
Lock: 6
Func lock: 4
Lock: 7
Func lock: 5
Lock: 8
Func lock: 6
Lock: 9
Func lock: 7
Lock: 10
Func lock: 8
Lock: 11
Func lock: 9
Func lock: 10
Func lock: 11
Func lock: 0
Func lock: 1
Func lock: 2
Func lock: 3
Func lock: 4
Func lock: 5
Func lock: 6
Func lock: 7
Func lock: 8
Func lock: 9
Func lock: 10
Func lock: 11
Func lock: 0
Func lock: 1
Func lock: 2
Func lock: 3
Func lock: 4
Func lock: 5
Func lock: 6
Func lock: 7
Func lock: 8
Func lock: 9
Func lock: 10
Func lock: 11
Func lock: 0
Func lock: 1
Func lock: 2
Func lock: 3
Func lock: 4
Func lock: 5
Func lock: 6
Func lock: 7
Func lock: 8
Func lock: 9
Func lock: 10
Func lock: 11
Func lock: 0
Func lock: 1
Func lock: 2
Func lock: 3
Func lock: 4
Func lock: 5
Func lock: 6
Func lock: 7
Func lock: 8
Func lock: 9
Func lock: 10
Func lock: 11
Func lock: 0
Func lock: 1
Func lock: 2
Func lock: 3
Func lock: 4
Func lock: 5
Func lock: 6
Func lock: 7
Func lock: 8
Func lock: 9
Func lock: 10
Func lock: 11

參考网址：http://www.kankanews.com/ICkengine/archives/19105.shtml