如果CAS尝试竞争成功，就直接执行代码块。如果失败，发现有其他线程在竞争撤销偏向锁，升级成为轻量级锁。

2.升级为轻量级锁线程尝试使用CAS将对象头中的Mark Word替换为指向锁记录的指针。如果成功,当前线程获得锁,如果失败,表示其他线程竞争锁,当前线程便尝试使用自旋来获取锁。

自旋锁尽可能的减少线程的阻塞，这对于锁的竞争不激烈，且占用锁时间非常短的代码块来说性能能大幅度的提升，因为自旋的消耗会小于线程阻塞挂起再唤醒的操作的消耗。

3.轻量级锁自旋获取锁依然失败，升级为重量级锁。

四、性能优化与测试

在并发编程中线程安全是我们首要要关注的问题，它是保证程序稳定运行的前提。但是锁的引入可能也是性能上的杀手。

4.1 多线程性能问题诱因

导致并发性能的主要诱因是"上下文切换"。

上线文切换

在多核的操作系统里，当一个线程被切换进来时，它所需要的数据可能不在当前处理器的缓存里，缓存的确实会使得这个线程初次的切换带来更多的开销。通常一次上下文的开销相当于5000~10000个cp4时钟周期。

引发上下切换的诱因是:阻塞IO,等待获取竞争锁等。

当线程发生阻塞或者等待获取竞争锁（cas,voliate都属于非竞争同步，JVM自行调度，无需操作系统介入)时，需要被挂起，这个过程将包含两次额外的上下文切换，被阻塞的线程在其执行的时间片还没有用完之前就被交换出去，而在随后的获取锁或者资源可用的时候再切换回来。

调用哪些方法会引起上线文切换（常见）：

• Thread.sleep(long millis)
• Object,wait(long timeout)
• Thread.join()/Thread.join(long timeout)

性能的影响因素也包含如内存同步等，这里只说上下文切换是主要诱因，可能人为的做优化的部分。

4.2 性能优化方案

4.2.1 减少锁力粒度

如果我们给public类每个方法加synchnorized(this)的同步，线程安全确实没问题。但是基本也等同于串列操作，违背了并发的本意。

在编码的时候尽量避免锁的力度太粗。避免占用锁的时间过长。

case：

public class Grocery {
private final ArrayList fruits = new ArrayList();
private final ArrayList vegetables = new ArrayList();
public synchronized void addFruit(int index, String fruit) {
fruits.add(index, fruit);
}
public synchronized void removeFruit(int index) {
fruits.remove(index);
}
public synchronized void addVegetable(int index, String vegetable) {
vegetables.add(index, vegetable);
}
public synchronized void removeVegetable(int index) {
vegetables.remove(index);
}
}

这里可以看出来在添加和移除水果的时候也会阻塞蔬菜的添加和删除，对于水果和蔬菜的增删操作都是方法域的同步。如果拆分下锁：

public class Grocery {
private final ArrayList fruits = new ArrayList();
private final ArrayList vegetables = new ArrayList();
public void addFruit(int index, String fruit) {
synchronized(fruits) fruits.add(index, fruit);
}
public void removeFruit(int index) {
synchronized(fruits) {fruits.remove(index);}
}
public void addVegetable(int index, String vegetable) {
synchronized(vegetables) vegetables.add(index, vegetable);
}
public void removeVegetable(int index) {
synchronized(vegetables) vegetables.remove(index);
}
}

锁的范围就被缩小到了针对每个资源fruits和vegetables的锁。通常这样的方式阻塞出现的情况会更加少，性能会有较大的提升。

4.2.2 使用非竞争同步

在cas和voliate关键字适用的场景可以尽量去选择使用此类乐观锁。

4.2.3 分段锁

分解锁可以带来一定的伸缩性和性能的提升，但是如果竞争条件还是比较激烈的话，还是会有问题，这时候可以通过分段锁来优化。jdk 1.7中的线程安全集合类ConcurrentHashMap就是利用了这个技术来实现高并发。

ConcurrentHashMap把容器分为多个 segment（片段） ，每个片段有一把锁，当多线程访问容器里不同数据段的数据时，线程间就不会存在竞争关系；一个线程占用锁访问一个segment的数据时，并不影响另外的线程访问其他segment中的数据。

@SuppressWarnings("unchecked")
public V put(K key, V value) {
Segment<K,V> s;
if (value == null)
throw new NullPointerException();
int hash = hash(key.hashCode()); //获取hash值
int j = (hash >>> segmentShift) & segmentMask; //mask计算出资源散列在哪个片段中
if ((s = (Segment<K,V>)UNSAFE.getObject // nonvolatile; recheck
(segments, (j << SSHIFT) + SBASE)) == null) // in ensureSegment
s = ensureSegment(j);
return s.put(key, hash, value, false);
}

ensureSegment找到segment位置之后，就可以开始执行Segment put操作，Segment.put被使用开销更小的ReentrantLock.trylock即非公平锁。

非公平锁（Nonfair）：加锁时不考虑排队等待问题，直接尝试获取锁，获取不到自动到队尾等待。

4.2.4 ReadWriteLock

如果资源可以被多个读线程访问，或者只有一个写线程访问，可以使用读写锁。也就是存在多个线程同时存在读和写的场景不适用。

资源并发读写：

红色部分表示被阻塞的线程

使用读写锁可以带来性能上的优化。Java 中的实现有ReentrantReadWriteLock。

实例读锁和写锁

private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
private final Lock r = rwl.readLock();
private final Lock w = rwl.writeLock();

获取锁和释放锁

lock()
unlock()

读锁的性能高于独占锁，读锁区别于写锁使用的是共享锁，具有更小的开销

4.3 编写测试代码

多线程的正确性通常很难通过肉眼甚至是正常测试回归发现。对于我们的并发代码的正确性需要更多的依赖测试代码的验证，这一点很重要。

但是编写多线程的单元测试通常比写多线程的逻辑代码更难，需要一些技巧。

4.3.1 覆盖基本的后验条件

首先假定在串列的条件下，是否能正确的都到正确的结果。使用单元测试先去覆盖掉。比如队列在创建之前应该为空的严重，完成之后后验结果的准确性。确保非并发的环境下程序是争取的，这样可以避免把所有错误怀疑到多线程上，也可以为多线程的后续结果验证提供基础。

4.3.2 使用栅栏模式(CyclicBarrier)设计"同时到达"

CyclicBarrier可以使线程互相等待，任何一个线程达到某个状态之前，所有的线程都必须等待。等到所有线程都达到某个状态，线程才能继续执行。

CyclicBarrier的代码模型：

//设计50个测试线程
int HREADS = 50 ;

CyclicBarrier barries = new CyclicBarrier(HREADS);

//in thread,wait to start
barries.await()

//do stuff

//in thread,wait to stop
barries.await();

case:

class Party extends Thread {
private int duration;
private CyclicBarrier barrier;

public Party(int duration, CyclicBarrier barrier, String name) {
super(name);
this.duration = duration;
this.barrier = barrier;
}

@Override
public void run() {
try {
Thread.sleep(duration);
System.out.println(Thread.currentThread().getName() + " is calling await()");
barrier.await();
System.out.println(Thread.currentThread().getName() + " has started running again");
} catch (InterruptedException | BrokenBarrierException e) {
e.printStackTrace();
}
}
}

Test:

public static void main(String args[]) throws InterruptedException, BrokenBarrierException {

CyclicBarrier barrier = new CyclicBarrier(4);
Party first = new Party(1000, barrier, "PARTY-1");
Party second = new Party(2000, barrier, "PARTY-2");
Party third = new Party(3000, barrier, "PARTY-3");
Party fourth = new Party(4000, barrier, "PARTY-4");

first.start();
second.start();
third.start();
fourth.start();

System.out.println(Thread.currentThread().getName() + " has finished");

}

4.3.3 产生更多的交替操作

低概率的事件即使是模拟多线程测试也很难验证出来，需要让程序产生更多的交替操作大概率去提高并发隐藏问题出现的概率。

借助Thread.sleep()/Thread.yield()，通常加到需要验证的逻辑之前。

public void run() {
try {
Thread.sleep(2);

//do stuff
} catch (InterruptedException | BrokenBarrierException e) {
e.printStackTrace();
}
}

Thread.sleep()/Thread.yield()都会阻塞使CPU让出时间片,让竞争更为激烈。

推荐阅读：