第三部分：java多线程锁，源码剖析
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
javascript:void(0)
眼下在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 的实现方式：
1.1 contentionlist 虚拟队列
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中可通过synchronizedkeyword锁锁住共享资源以实现异步多线程的达到同步。
总结起来。要达到同步。我们要做的就是构造各线程间的共享资源。当中的共享资源能够对象，也能够是方法。
执行结果例如以下所看到的（尽供參考分析）：
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
func lock: 7
func lock: 8
func lock: 9
func lock: 10
func lock: 11
no lock: 0
no lock: 1
no lock: 2
no lock: 3
no lock: 4
no lock: 5
no lock: 6
no lock: 7
no lock: 8
no lock: 9
no lock: 10
no lock: 11