》》线程安全与锁优化
1.1概述
什么是线程安全 ? 《Java并发编程实战》的作者Brian Goetz为"线程安全"做出了一个比较恰当的定义:当多个线程同时访问一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方进行任何其他的协调操作，调用这个对象的行为都可以获得正确的结果，那就称这个对象是线程安全的。
这个定义就很严谨而且有可操作性性，它要求线程安全的代码都必须具备一个共同特征：代码本省封装了所有必要的正确性保障手段(如互斥同步等)，令调用者无需关心多线程下的调用问题，更无须自己实现任何措施来保证多线程环境下的正确调用。
Java语言中的线程安全
在Java语言中，线程安全具体是如何体现的？有哪些操作是线程安全的？我们这里讨论的线程安全，将以多个线程之间存在共享数据访问为前提，因为如果根本不存在多线程，又或者一段代码根本不会与其他线程共享数据，那么从线程安全的角度上看，程序是串行执行还是多线程执行对它来说是没有什么区别的。
为了更深入的理解线程安全，在这里我们可以不把线程安全当做一个非真即假的二元排它选项来看待，而是按照线程安全的 “安全程度” 由强至弱来排序，我们可以将Java语言中各种操作共享的数据分为下面五类： 不可变、绝对线程安全、相对线程安全、线程兼容和线程对立。
1.不可变
在Java语言里(特指JDK5以后，即Java内存模型被修正之后的Java语言)，不可变(Immutable)的对象一定是线程安全的，无论是对象的方法实现还是方法的调用者，都不需要再进行线程安全保障措施。前面我们讲过 "final关键字带来的可见性"时曾经提到过这一点: 只要一个不可变的对象被正确的构建出来(即没有发生this引用逃逸)，那其外部的可见状态永远都不会改变，永远都不会看到它在多个线程之中处于不一致的状态，"不可变"带来的安全性是最直接 最纯粹的
典型的不可变对象就是java.lang.String，其底层的char型数组被声明为final，还有枚举类型以及java.lang.Number的部分子类，如Long和Double以及Integer等数值保证类型
2.绝对线程安全
绝对的线程安全能够完全满足上面给出的线程安全定义，这个定义其实是很严格的，一个类要达到"不管运行时环境如何，调用者都不需要任何额外的同步措施"，可能需要付出非常高昂、甚至不切实际的代价。在Java API中标注自己是线程安全的类，大多数都不是绝对的线程安全，我们可以通过Java API中一个不是"绝对线程安全"的"线程安全类型"来看看这个语境中的 "绝对"究竟是什么意思。
如果说java.util.Vector是一个线程安全的容器，相信所有的Java程序员都对此不会有异议，因为它的add()、get()、和size()等方法都是被synchronized修饰的，尽管这样效率不高，但保证了具备原子性、可见性和有序性。不过，即使所有的方法都被修饰成synchronized的，也不意味着调用它的时候就永远不再需要同步手段了。看下面代码。
private static Vector<Integer> vector = new Vector<Integer>
public static void main(String[] args){
while(true){
for(int i = 0; i < 10; i ++ ){
vector.add(i);
}
Thread removeThread = new Thread(new Runnable(){
@Override
public void run(){
for(int i = 0; i < vector.size(); i ++ ){
vector.remove(i);
}
}
});
Thread printThread = new Thread(new Runnable(){
@Override
public void run(){
for(int i = 0; i < vector.size(); i ++ ){
System.out.print(vector.get(i));
}
}
});
removeThread.start();
printThread.start();
//不要同时产生过多的线程，否则会导致操作系统假死
while(Thread.activeCount > 20);
}
}
运行结果出现了下标越界异常。
很明显，尽管这里使用到了vector的get()、remove()、和size()、方法都是同步的，但是在多线程环境下，如果不在方法调用端做额外的同步措施，使用这段代码仍然是不安全的，因为如果另一线程恰好在错误的时间里删除了一个元素，导致索引i已经不可再用，再用i访问数组就会抛出一个ArrayIndexOutOfBoundsException异常。如果保证这段代码能正确的执行下去，我们不得不把removeThread和printThread的定义修改。
Thread removeThread = new Thread(new Runnable(){
@Override
public void run(){
synchronized (vector){
//加锁
for(int i = 0; i < vector.size(); i ++ ){
vector.remove(i);
}
}
}
});
Thread printThread = new Thread(new Runnable(){
@Override
public void run(){
synchronized (vector){
//加锁
for(int i = 0; i < vector.size(); i ++ ){
System.out.print(vector.get(i));
}
}
}
});
3.相对线程安全
相对线程安全就是我们通常意义上所讲的线程安全，他需要保证对这个对象单次的操作是线程安全的，我们在调用的时候不需要进行额外的保障措施，但是对于一些特定顺序的连续调用，就可能需要在调用端使用额外的同步手段来保证调用的正确性，上面的代码就是相对线程安全的案例。
在Java语言中，大部分声称线程安全的类都属于这种类型，例如vector、HashTable，Collections的synchronizedCollection()方法包装的集合等
4.线程兼容
线程兼容是指对象本身并不是线程安全的，但是可以通过调用端正确的使用同步手段来保证在并发环境中可以安全的使用，我们平常说的一个类不是线程安全的，通常就是指这种情况，Java类库API中大部分的类都是线程兼容的，如与前面的Vector和HashTable相对应的集合类ArrayList和HashMap
5.线程对立
线程对立是指不管调用端是否采取了同步措施，都无法在多线程环境中并发使用代码，由于Java语言天生就支持多线程的特性，线程对立这种排斥多线程的代码是很少出现的，而且通常都是有害的，应该避免。
1.2线程安全的实现方法
1.2.1互斥同步
互斥同步是一种最常见也是最主要的并发正确性保障手段，同步是指在多个线程并发访问共享数据时，保证共享数据在同一时刻只被一条(或是一些，当时用信号量的时候)线程使用，而互斥是实现同步的一种手段，临界区(Critical)、**互斥量(Mutex)和信号量(Semaphore)**都是常见的互斥实现方式，因此在 “互斥同步” 这四个字里，互斥是因、同步是果；互斥是方法，同步是目的。互斥 ——> 同步。
在Java里面，最基本的互斥同步手段就是synchronized关键字，这时一种块结构(Block Structured)的同步语法，synchronized关键字经过javac编译后，会在同步块的前后分别形成monitorenter和monitorexit这两个字节码指令。这两个字节码指令都需要一个reference类型的参数来指明要锁定和要解锁的对象。
- 如果synchronized明确指定了对象参数，那就以这个对象的引用作为reference；
- 如果没有明确指定，那将根据synchronized修饰的方法类型(如实例方法或类方法)，来决定是取代码所在的对象实例还是取类型对应的Class对象来作为线程要持有的锁
(主要看方法是否是静态方法)
根据《Java虚拟机规范》的要求，在执行**monitorenter(加锁)**指令时，首先要去尝试获取对象的锁，如果这个对象没被锁定，或者当前线程已经持有了那个对象的锁，就要把锁的计数器的值加一，而在执行monitorexit指令时会将锁计数器的值减一，一旦计数器的值为0，锁随即就被释放了，如果获取对象锁失败，那当前线程就应当被阻塞等待，直到请求锁定的对象被持有它的线程释放为止
从功能上看，根据《Java虚拟机规范》对monitorenter和monitorexit的行为描述，我们可以得出两个关于synchronized的直接推论，这是使用它时需特别注意的：
-
被synchronized修饰的同步块对同一条线程来说是
可重入的，这意味着同一线程反复进入同步块也不会出现自己把自己锁死的情况(可重入性是指一条线程能够反复进入被它自己持有锁的同步块的特性，即锁关联的计数器，如果持有锁的线程再次获得它，则将计数器的值加一，每次释放锁时计数器的值减一，当计数器的值为0时，才能真正的释放锁)
-
被synchronized修饰的同步块在持有锁的线程执行完毕并释放锁之前，会无条件的阻塞后面其他线程的进入。这意味着无法像处理某些数据库中的锁那样，强制已获取锁的线程释放锁；也无法强制正在等待锁的线程中断等待或超时退出。
从执行成本的角度来看，持有锁是一个**重量级(Heavy-Weight)**的操作。在前面我们知道在主流的Java虚拟机实现中，Java的线程是映射到操作系统的原生内核线程之上的，如果要阻塞或者唤醒一条线程，则需要操作系统来完成，这就不可避免地陷入用户态到和核心态的转换中，进行这种状态转换需要耗费很多的处理器时间。
JUC中的Lock锁
从上面的介绍中我们可以synchronized的局限性，除了synchronized关键字以外，自JDK5起(实现了JSR166)，Java类库中新提供了JUC包，其中的Lock接口便成了Java的另一种全新的互斥同步手段，基于Lock接口，用户能够以非块结构来实现互斥同步。
重入锁(ReentrantLock)是Lock接口最常见的一种实现，顾名思义，它与synchronized一样是可重入的，在基本用法上，ReentrantLock也与synchronized很相似，只是代码写法上稍有区别而已，不过ReentrantLock与synchronized相比增加了一些高级功能，主要有以下三项: 等待可中断、可实现公平锁及锁可以绑定多个条件。
- 等待可中断
是值当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情，可中断特性对处理执行时间爱你非常长的同步块很有帮助
- 公平锁
是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序依次获得锁，而非公平锁不保证这一点，在锁被释放时，任何一个等待锁的线程都有机会获得锁，synchronized中的锁默认是非公平的，ReentrantLock在默认情况下也是非公平的，但可以通过带布尔值的构造函数要求使用公平锁，不过一旦使用了公平锁，将会导致ReentrantLock的性能急剧下降，会明显影响吞吐量。
- 锁绑定多个条件
值一个ReentrantLock对象可以同时绑定多个Condition对象。在synchronized中，锁对象的wait跟它的notify()或者notifyAll()方法配合可以实现一个隐含的条件，如果要和多余一个条件关联的时候，就不得不额外添加一个锁；而ReentrantLock则无需这样做，多次调用new Condition()方法即可。
synchronized和Lock对比与选择
在JDK6之前Lock的性能是好于synchronized的，而在JDK6中加入了大量针对synchronized锁的优化后，相同的测试中就发现两者的性能基本能够持平。相信现在大家所开发的程序都是使用JDK6或者以上版本的，所以性能已经不是选择两者的决定因素。
根据上面的讨论，ReentrantLock在功能上是synchronized的超集，在性能上至少不会弱于synchronized，那synchronized修饰符是否应该被直接抛弃，不在使用了呢？当然不是，基于一下理由，本书作者(zzm)仍然推荐在synchronized和ReentrantLock都可满足需求时优先使用synchronized。
- synchronized是在Java语法层面的同步，足够清晰，也足够简单，每个Java程序员都熟悉synchronized，但JUC中的Lock接口则并非如此，因此在只需要基础的同步功能时，更推荐synchronized。
- Lock应该确保在finally块中释放锁，否则一旦受保护同步代码块中抛出异常，则有可能永远不会释放释放持有的锁，这一点必须由程序员自己来保证，而使用synchronized的话则可以由Java虚拟机来确保即使出现异常，锁也能被自动释放
- 尽管在JDK5时代ReentrantLock曾经在性能上领先过synchronized，但这已经是十多年之前的胜利了，从长远来看，Java虚拟机更容易针对synchronized来进行优化，因为Java虚拟机可以在线程和对象的元数据中记录synchronized中锁的相关信息，而是用JUC的Lock的话，Java虚拟机是很难得值具体哪些锁对象是由特定线程锁持有的。
1.2.2非阻塞同步
互斥同步面临的主要问题是进行线程阻塞和唤醒所带来的性能开销，因此这种同步也被称为阻塞同步(Blocking Synchronized)。
从解决问题的方式上看，互斥同步属于一种悲观的并发策略，其总是认为只要不去做正确的的同步措施(例如加锁)，那就肯定会出现问题，无论共享的数据是否真的会出现竞争，它都会进行加锁(这里讨论的是概念模型、实际上虚拟机会优化掉很大一部分不必要的加锁)，这就会导致用户态到核心态的转换、维护锁计数器和检查是否有被阻塞的线程需要被唤醒等开销。
随着硬件指令集的发展，我们已经有了另外一个选择: 基于冲突检测的乐观并发策略，通俗的说就是不管风险，先进行操作，如果没有其他线程争用共享数据，那操作就直接成功了；如果共享的数据的确被争用，产生了冲突，那再进行其他的补偿措施，最常用的补偿措施就是不断的重试，知道出现没有竞争的共享数据为止。这种乐观并发策略的实现不再需要把线程阻塞挂起，因此这种同步操作被称为非阻塞同步(Non-Blocking Synchronized)，使用这种措施的代码也常被称为无锁(Lock-Free)编程
为什么说使用乐观并发策略需要"硬件指令集的发展" ？ 因为我们必须要求操作和冲突检测这两个步骤具备原子性。靠什么来保证原子性？如果这里再使用互斥同步来保证就失去意义了，所说我们只能靠硬件来实现这件事情，硬件保证某些从语义上看起来需要多次操作的行为可以通只通过一条处理器指令就能完成，这类指令常用的有：
- 测试并设置(Test-and-Set)
- 获取并增加(Fetch-and-Increment)
- 交换(Swap)
比较并交换(Compare-and-Swap，下文称CAS)- 加载链接 / 条件存储(Load-Linked / Store-Conditional)
CAS指令需要有三个操作数，分别是内存位置V(在Java中可以简单地理解为变量的内存地址，用V表示)、旧的预期值(用A表示)和准备设置的新值(用B表示)。CAS指令执行时，当且仅当V符合A时，处理器才会用B更新V的值，否则它就不执行更新。但是，不管是否更新了V的值，都会返回V的旧值，上述的处理过程就是一个原子操作，执行期间不会被其他线程中断。
CAS代替加锁实例
上一章我们在测试volatile修饰的int型变量a在多线程下进行++操作是不安全的，执行10000次++操作，最终的a的值是小于10000的。我们使用synchronized加锁操作保证了最终的a是10000。
接下来我们使用AtomicInteger代替int后，程序也输出了正确的结果，这一切都要归功于incrementAndSet()方法的原子性，它的实现其实非常简单。
public final int incrementAndGet(){
for(; ;){
int current = get(); //获取当前值
int next = current + 1; //要修改的值
if(compareAndSet(current, next)){
//CAS操作，更新值
return next;
}
}
}
incrementAndGet()方法在一个无限循环中，不断尝试将一个比当前值大一的新值赋值给自己，如果失败了，那说明在执行CAS操作的时候，旧值已经发生了改变，于是再次循环进行下一次操作，直到设置成功位置。
ABA问题
尽管CAS看起来很美好，既简单又高效，但显然这种操作无法涵盖互斥同步的所有使用场景，并且CAS从语义上来说并不是真正完美的，它存在一个逻辑漏洞：如果一个变量V初次读取的时候是A，并且在准备赋值的时候检查到它仍然是A值，那就能说明它的值没有被其他线程改变过了吗？ 这是不能的，因为如果在这段期间它的值曾经被改成B，后来又被改成A，那CAS操作就会误认为它从来没有被改变过。这个漏洞称为CAS操作的 "ABA"问题。
JUC包为了解决这个问题，提供了一个带有标记的原子引用类AtomicStampedReference，它可能通过控制变量值的版本来保证CAS的正确性。不过目前来说这个类处于相当鸡肋的位置，大部分情况下ABA问题不会影响程序并发的正确性，如果要解决ABA问题，改用传统的互斥同步可能会比原子类更为高效。
1.3锁优化
1.3.1概述
高效并发是JDK5升级到JDK6后的一项很重要的改进项，HotSpot虚拟机开发团队在这个版本上花费了大量的资源去实现各种锁优化技术，如适应性自旋(Adaptive)、锁消除(Lock Elimination)、锁膨胀(Lock Coarsening)、轻量级锁(Lightweight Locking)、偏向锁(Biased Locking)等，这些技术都是为了在线程之间更高效地共享数据即解决竞争问题，从而提高程序的执行效率。
1.3.2自旋锁与自适应自旋
前面我们讨论互斥同步的时候，提到了互斥同步对性能最大的影响是阻塞的实现，挂起线程和恢复线程的操作都需要转入内核态中完成，这些操作给Java虚拟机的并发性能带来了很大的压力。
同时，虚拟机的开发团队也注意到在许多应用上，共享数据的锁定状态只会持续很短的一段时间，为了这段时间去挂起和恢复线程并不值得。现在绝大多数数的个人电脑和服务器都是多路(核)处理器系统，如果物理机器有一个以上的处理器或者处理器核心，能让两个或以上的线程同时并发执行，我们就可以让后面的请求锁的那个线程 “稍等一会”，但不放弃处理器的执行时间，看看持有锁的线程是否很快就会释放锁，为了让线程等待，我们只需要让线程执行一个忙循环(自旋 不挂起线程)，这项技术就是所谓的自旋锁。
自旋锁在JDK1.4.2中就已经引入，只不过默认是关闭的，可以使用-XX：+UseSpinning参数来开启，在JDK6中就已经改为默认开启了。
自旋等待不能代替阻塞，且先不说对处理器数量的要求，自旋等待本身虽然避免了线程切换的开销，但它是要占用处理器时间的，所以如果锁被占用的时间很短，自选等待的效果就会非常好，反之如果锁被占用的时间很长，那么自旋的线程只会白白消耗处理器资源，而不会做任何有价值的工作，这就会带来性能的浪费。
因此自旋等待的时间必须有一定的限度，如果自旋超过了限定的次数仍然没有成功获得锁，就应当使用传统的方式(阻塞)去挂起线程。自旋次数的默认值是10次，用户也可以使用参数-XX:PreBlocksSpin来自行更改。
自适应自旋锁
在JDK6中对自旋锁的优化，引入了自适应的自旋。自适应意味着自旋的时间不再是固定的了，而是由前一次在同一个锁上的自旋时间及锁的拥有者的状态来决定的。
如果在同一个锁对象上，自旋等待刚刚成功获得过锁，并且持有锁的线程正在运行中，那么虚拟机就会认为这次自旋也很有可能再次成功，进而允许自旋等待持续相对更长的时间，比如持续100次循环。另一方面，如果对于某个锁，自旋很少成功获得过锁，那在以后要获取这个锁时将有可能直接省略掉自旋过程。以避免浪费处理器资源。有了自适应自旋，随着程序运行时间的增长及性能监控信息的不断完善，虚拟机对程序锁的状况预测就会越来越精准，虚拟机就会变得越来越 “聪明” 了。
1.3.3锁消除
锁消除是指在虚拟机即时编译器在运行时，带一些代码要求同步，但是对检测到不可能存在共享数据竞争的锁进行消除。
锁消除的主要判定一句来源于逃逸分析的数据支持，如果判断到一段代码中，在堆上的所有数据都不会逃逸出去被其他线程访问到，那就可以把它们当做栈上数据对待，认为它们是线程私有的，同步加锁自然也就无须在进行。
1.3.4锁粗化
原则上，我们在编写代码时，总是推荐将同步块的作用范围限制的尽量小——只在共享数据的实际作用域中才进行同步，这样是为了使得需要同步的操作数量尽可能变少，即使存在锁竞争，等待锁的线程也能尽可能快的拿到锁。
大多数情况下，上面的原则都是正确的，但是如果一系列的连续操作都对同一个对象反复加锁和解锁，甚至加锁操作是出现在循环体中的，那即使没有线程竞争，频繁地进行互斥同步操作也会导致不必要的性能损耗。
如果虚拟机探测到有这样一串零碎的操作都对同一个对象加锁，将会把加锁同步的范围扩展(粗化)到整个操作序列的外部。
1.3.5轻量级锁
轻量级锁是JDK6时加入的新型锁价值，它名字中的 “轻量级” 是相对于使用操作系统互斥量来实现传统锁而言的。因此传统的锁机制就被称为"重量级"锁。不过，需要强调一点，轻量级锁并不是用来代替重量级锁的，它设计的初衷是在没有多线程竞争的前提下，减少传统的重量级锁使用操作系统互斥量产生的性能消耗
要理解轻量级锁，以及后面会讲到的偏向锁的原理和运作过程，必须要对HotSpot虚拟机对象的内存布局(参考JVM_4.对象的实例化布局与访问定位)尤其是对象头有所了解。HotSpot虚拟机的对象头分为两部分，第一部分用于存储对象自身的运行时数据，如哈希码(HashCode)、GC年龄分代、锁标志位等信息，这部分数据的长度在32位和64位的Java虚拟机中分别会占32个或64个比特。官方称为"Mark Word".这部分是实现轻量级锁和偏向锁的关键 另外一部分用于存储指向方法区对象类型的指针，如果是数组对象，还会有一个额外的部分用于存储数组长度。
由于对象头信息是与对象自身定义的数据无关的额外存储成本，考虑到Java虚拟机的空间使用效率，Mark Word被设计成一个非固定的动态数据结构。以便在极小的空间内存储更多的信息。它会根据对象的状态复用自己的存储空间，例如在32位的HotSpot虚拟机中，对象未被锁定的状态下，Mark Word的32个比特空间里的25个比特将用于存储对象哈希码，4个比特用于存储对象年龄分代年龄，2个比特用于存储锁标志位，还有1个比特固定为0(表示未进入偏向模式)。对象除了未被锁定的正常状态下，还有轻量级锁定、重量级锁定、GC标记、可偏向等几种不同状态。这些状态下对象头的存储内容如下。
轻量级锁工作过程
在代码即将进入同步块时，如果此同步对象没有被锁定(锁标志位为01)， 虚拟机首先将在当前线程的栈帧中建立一个名为锁记录(Lock Record)的空间，用于存储锁对象目前的Mark Word的拷贝(官方为这份拷贝加了一个Displaced的前缀，即Displaced Mark Word)，
然后，虚拟机使用CAS操作尝试把对象的Mark Word更新为指向Lock Record的指针。如果这个更新操作成功了，即代表线程拥有了这个对象的锁，并且对象Mark Word的锁标志位将转换为00 ，这时候线程堆栈与对象头的状态如下图所示
如果这个更新操作失败了，那就意味着至少存在一条线程与当前线程竞争获取该对象的锁，虚拟机首先会检查对象的Mark Word是否指向当前线程的栈帧，如果是，说明当前线程已经拥有了这个对象的锁，那直接进入同步块中继续执行就可以了，否则就说明这个锁对象已经被其他线程抢占了，如果出现两条以上的线程争用同一个锁的情况，那轻量级锁就不在有效，必须要膨胀为重量级锁，锁标志的状态值变为"10",此时Mark Word中存储的就是重量级锁(互斥量)的指针，后面等待锁的线程也必须进入阻塞状态。
上述描述的是轻量级锁的加锁过程，它的解锁过程也同样是通过CAS操作来进行的，如果对象的Mark Word仍然指向线程的锁记录，那就用CAS操作把对象当前的Mark Word和线程中复制的Displaced Mark Word替换回来，假如能够成功替换，那整个同步过程就顺利完成；如果替换失败，则说明有其他线程尝试过获取该锁，就要在释放锁的同时，唤醒被挂起的线程。
轻量级锁能提升程序同步性能的依据是：对于绝大部分的锁，在整个同步周期内都是不存在竞争的 这一经验法则。如果没有竞争，轻量级锁便通过CAS操作成功避免了使用互斥量的开销；但如果确实存在锁竞争，除了互斥量本身开销外，还额外发生了CAS操作的开销，因此在有竞争的情况下，轻量级锁反而会比传统的重量级锁更慢。
1.3.6 偏向锁
偏向锁也是JDK6中引入的一项锁优化措施，它的目的是消除数据在无竞争情况下的同步原语，进一步提高程序的运行性能，如果说轻量级锁是在无竞争的情况下使用CAS操作去消除同步使用的互斥量，那偏向锁就是在无竞争的情况下把整个同步都消除掉，连CAS操作都不需要了。
偏向锁中的 “偏”，就是偏心的 ''偏"， 偏袒的偏，他的意思是这个锁会偏向于第一个获得它的线程，如果在接下来的执行过程中，该锁一直没有被其他线程获取，则持有偏向锁的线程将永远不需要再进行同步。
如果理解了前面轻量级锁中关于对象头Mark Word与线程之间的操作过程，那偏向锁的原理就会很容易理解。假设当前虚拟机启用了偏向锁(启用参数-XX: +UseBiasedLocking，这是自JDK6起HotSpot虚拟机的默认值)，那么当锁对象第一次被线程获取时，虚拟机将会把对象头中的标志位设置为 "01"，把偏向模式设置为"1"，表示进入偏向模式。同时使用CAS操作把获取到这个锁的线程ID记录在对象头的Mark Word中。如果CAS操作成功，持有偏向锁的线程以后每次进入这个锁相关的同步块时，虚拟机都可以不再进行任何同步操作(例如加锁、解锁及对Mark Word的更新操作)
一旦出现另外一个线程去尝试获取这个锁的情况，偏向模式马上就宣告结束。根据锁对象目前是否处于被锁定的状态决定是否撤销偏向(偏向模式设置为"0" 0代表未偏向)，撤销后标志位恢复到**未被锁定(标志位为"01")或轻量级锁(标志位为"00")**的状态，后续的同步操作就按照上面的轻量级锁那样去执行。偏向锁、轻量级锁的状态转化及对象Mark Word的关系如下图所示。
偏向锁可以提高带有同步但无竞争的程序性能，但它同样是一个带有效益权衡(Trade Off)性质的优化，也就是说它并非总是对程序运行有利，如果程序中大多数的锁都总是被多个不同的线程访问，那偏向模式就是多余的。在具体问题具体分析的前提下，有时候使用参数-XX:UseBiasedLocking来禁止偏向锁反而可以提高性能。