自旋锁实现及优化

在聊聊高并发（五）理解缓存一致性协议以及对并发编程的影响 我们了解了处理器缓存一致性协议的原理，并且提到了它对并发编程的影响，“多个线程对同一个变量一直使用CAS操作，那么会有大量修改操作，从而产生大量的缓存一致性流量，因为每一次CAS操作都会发出广播通知其他处理器，从而影响程序的性能。”

这一篇我们通过两种实现自旋锁的方式来看一下不同的编程方式带来的程序性能的变化。

先理解一下什么是自旋，所谓自旋就是线程在不满足某种条件的情况下，一直循环做某个动作。所以对于自旋锁来锁，当线程在没有获取锁的情况下，一直循环尝试获取锁，直到真正获取锁。

在聊聊高并发（三）锁的一些基本概念 我们提到锁的本质就是等待，那么如何等待呢，有两种方式

1. 线程阻塞

2. 线程自旋

阻塞的缺点显而易见，线程一旦进入阻塞(Block)，再被唤醒的代价比较高，性能较差。自旋的优点是线程还是Runnable的，只是在执行空代码。当然一直自旋也会白白消耗计算资源，所以常见的做法是先自旋一段时间，还没拿到锁就进入阻塞。JVM在处理synchrized实现时就是采用了这种折中的方案，并提供了调节自旋的参数。

这篇说一下两种最基本的自旋锁实现，并提供了一种优化的锁，后续会有更多的自旋锁的实现。

首先是TASLock （Test And Set Lock），测试-设置锁，它的特点是自旋时，每次尝试获取锁时，采用了CAS操作，不断的设置锁标志位，当锁标志位可用时，一个线程拿到锁，其他线程继续自旋。

缺点是CAS操作一直在修改共享变量的值，会引发缓存一致性流量风暴

[java] view plain copy print?

1. package com.test.lock;  
2.   
3. // 锁接口  
4. public interface Lock {  
5.     public void lock();  
6.       
7.     public void unlock();  
8. }  
9.   
10.   
11.   
12.   
13. package com.test.lock;  
14.   
15. import java.util.concurrent.atomic.AtomicBoolean;  
16.   
17. /** 
18.  * 测试-设置自旋锁，使用AtomicBoolean原子变量保存状态 
19.  * 每次都使用getAndSet原子操作来判断锁状态并尝试获取锁 
20.  * 缺点是getAndSet底层使用CAS来实现，一直在修改共享变量的值，会引发缓存一致性流量风暴 
21.  * **/  
22. public class TASLock implements Lock{  
23.     private AtomicBoolean mutex = new AtomicBoolean(false);  
24.       
25.     @Override  
26.     public void lock() {  
27.         // getAndSet方法会设置mutex变量为true，并返回mutex之前的值  
28.         // 当mutex之前是false时才返回，表示获取锁  
29.         // getAndSet方法是原子操作，mutex原子变量的改动对所有线程可见  
30.         while(mutex.getAndSet(true)){  
31.               
32.         }  
33.     }  
34.   
35.     @Override  
36.     public void unlock() {  
37.         mutex.set(false);  
38.     }  
39.   
40.     public String toString(){  
41.         return "TASLock";  
42.     }  
43. }  

package com.test.lock;

// 锁接口
public interface Lock {
    public void lock();
    
    public void unlock();
}




package com.test.lock;

import java.util.concurrent.atomic.AtomicBoolean;

/**
 * 测试-设置自旋锁，使用AtomicBoolean原子变量保存状态
 * 每次都使用getAndSet原子操作来判断锁状态并尝试获取锁
 * 缺点是getAndSet底层使用CAS来实现，一直在修改共享变量的值，会引发缓存一致性流量风暴
 * **/
public class TASLock implements Lock{
	private AtomicBoolean mutex = new AtomicBoolean(false);
	
	@Override
	public void lock() {
		// getAndSet方法会设置mutex变量为true，并返回mutex之前的值
		// 当mutex之前是false时才返回，表示获取锁
		// getAndSet方法是原子操作，mutex原子变量的改动对所有线程可见
		while(mutex.getAndSet(true)){
			
		}
	}

	@Override
	public void unlock() {
		mutex.set(false);
	}

	public String toString(){
		return "TASLock";
	}
}

一种改进的算法是TTASLock（Test Test And Set Lock）测试-测试-设置锁，特点是在自旋尝试获取锁时，分为两步，第一步通过读操作来获取锁状态，当锁可获取时，第二步再通过CAS操作来尝试获取锁，减少了CAS的操作次数。并且第一步的读操作是处理器直接读取自身高速缓存，不会产生缓存一致性流量，不占用总线资源。

缺点是在锁高争用的情况下，线程很难一次就获取锁，CAS的操作会大大增加。

[java] view plain copy print?

1. package com.test.lock;  
2.   
3. import java.util.concurrent.atomic.AtomicBoolean;  
4.   
5. /** 
6.  * 测试-测试-设置自旋锁，使用AtomicBoolean原子变量保存状态 
7.  * 分为两步来获取锁 
8.  * 1. 先采用读变量自旋的方式尝试获取锁 
9.  * 2. 当有可能获取锁时，再使用getAndSet原子操作来尝试获取锁 
10.  * 优点是第一步使用读变量的方式来获取锁，在处理器内部高速缓存操作，不会产生缓存一致性流量 
11.  * 缺点是当锁争用激烈的时候，第一步一直获取不到锁，getAndSet底层使用CAS来实现，一直在修改共享变量的值，会引发缓存一致性流量风暴 
12.  * **/  
13. public class TTASLock implements Lock{  
14.   
15. private AtomicBoolean mutex = new AtomicBoolean(false);  
16.       
17.     @Override  
18.     public void lock() {  
19.         while(true){  
20.             // 第一步使用读操作，尝试获取锁，当mutex为false时退出循环，表示可以获取锁  
21.             while(mutex.get()){}  
22.             // 第二部使用getAndSet方法来尝试获取锁  
23.             if(!mutex.getAndSet(true)){  
24.                 return;  
25.             }     
26.               
27.         }  
28.     }  
29.   
30.     @Override  
31.     public void unlock() {  
32.         mutex.set(false);  
33.     }  
34.   
35.     public String toString(){  
36.         return "TTASLock";  
37.     }  
38. }  

package com.test.lock;

import java.util.concurrent.atomic.AtomicBoolean;

/**
 * 测试-测试-设置自旋锁，使用AtomicBoolean原子变量保存状态
 * 分为两步来获取锁
 * 1. 先采用读变量自旋的方式尝试获取锁
 * 2. 当有可能获取锁时，再使用getAndSet原子操作来尝试获取锁
 * 优点是第一步使用读变量的方式来获取锁，在处理器内部高速缓存操作，不会产生缓存一致性流量
 * 缺点是当锁争用激烈的时候，第一步一直获取不到锁，getAndSet底层使用CAS来实现，一直在修改共享变量的值，会引发缓存一致性流量风暴
 * **/
public class TTASLock implements Lock{

private AtomicBoolean mutex = new AtomicBoolean(false);
	
	@Override
	public void lock() {
		while(true){
			// 第一步使用读操作，尝试获取锁，当mutex为false时退出循环，表示可以获取锁
			while(mutex.get()){}
			// 第二部使用getAndSet方法来尝试获取锁
			if(!mutex.getAndSet(true)){
				return;
			}	
			
		}
	}

	@Override
	public void unlock() {
		mutex.set(false);
	}

	public String toString(){
		return "TTASLock";
	}
}

针对锁高争用的问题，可以采取回退算法，即当线程没有拿到锁时，就等待一段时间再去尝试获取锁，这样可以减少锁的争用，提高程序的性能。

[java] view plain copy print?

1. package com.test.lock;  
2.   
3. import java.util.Random;  
4.   
5. /** 
6.  * 回退算法，降低锁争用的几率 
7.  * **/  
8. public class Backoff {  
9.     private final int minDelay, maxDelay;  
10.       
11.     private int limit;  
12.       
13.     final Random random;  
14.       
15.     public Backoff(int min, int max){  
16.         this.minDelay = min;  
17.         this.maxDelay = max;  
18.         limit = minDelay;  
19.         random = new Random();  
20.     }  
21.       
22.     // 回退，线程等待一段时间  
23.     public void backoff() throws InterruptedException{  
24.         int delay = random.nextInt(limit);  
25.         limit = Math.min(maxDelay, 2 * limit);  
26.         Thread.sleep(delay);  
27.     }  
28. }  
29.   
30. package com.test.lock;  
31.   
32. import java.util.concurrent.atomic.AtomicBoolean;  
33.   
34. /** 
35.  * 回退自旋锁，在测试-测试-设置自旋锁的基础上增加了线程回退，降低锁的争用 
36.  * 优点是在锁高争用的情况下减少了锁的争用，提高了执行的性能 
37.  * 缺点是回退的时间难以控制，需要不断测试才能找到合适的值，而且依赖底层硬件的性能，扩展性差 
38.  * **/  
39. public class BackoffLock implements Lock{  
40.   
41.     private final int MIN_DELAY, MAX_DELAY;  
42.       
43.     public BackoffLock(int min, int max){  
44.         MIN_DELAY = min;  
45.         MAX_DELAY = max;  
46.     }  
47.       
48.     private AtomicBoolean mutex = new AtomicBoolean(false);  
49.       
50.     @Override  
51.     public void lock() {  
52.         // 增加回退对象  
53.         Backoff backoff = new Backoff(MIN_DELAY, MAX_DELAY);  
54.         while(true){  
55.             // 第一步使用读操作，尝试获取锁，当mutex为false时退出循环，表示可以获取锁  
56.             while(mutex.get()){}  
57.             // 第二部使用getAndSet方法来尝试获取锁  
58.             if(!mutex.getAndSet(true)){  
59.                 return;  
60.             }else{  
61.                 //回退  
62.                 try {  
63.                     backoff.backoff();  
64.                 } catch (InterruptedException e) {  
65.                 }  
66.             }      
67.               
68.         }  
69.     }  
70.   
71.     @Override  
72.     public void unlock() {  
73.         mutex.set(false);  
74.     }  
75.   
76.     public String toString(){  
77.         return "TTASLock";  
78.     }  
79. }  
80.   
81.    

package com.test.lock;

import java.util.Random;

/**
 * 回退算法，降低锁争用的几率
 * **/
public class Backoff {
	private final int minDelay, maxDelay;
	
	private int limit;
	
	final Random random;
	
	public Backoff(int min, int max){
		this.minDelay = min;
		this.maxDelay = max;
		limit = minDelay;
		random = new Random();
	}
	
	// 回退，线程等待一段时间
	public void backoff() throws InterruptedException{
		int delay = random.nextInt(limit);
		limit = Math.min(maxDelay, 2 * limit);
		Thread.sleep(delay);
	}
}

package com.test.lock;

import java.util.concurrent.atomic.AtomicBoolean;

/**
 * 回退自旋锁，在测试-测试-设置自旋锁的基础上增加了线程回退，降低锁的争用
 * 优点是在锁高争用的情况下减少了锁的争用，提高了执行的性能
 * 缺点是回退的时间难以控制，需要不断测试才能找到合适的值，而且依赖底层硬件的性能，扩展性差
 * **/
public class BackoffLock implements Lock{

    private final int MIN_DELAY, MAX_DELAY;
    
    public BackoffLock(int min, int max){
        MIN_DELAY = min;
        MAX_DELAY = max;
    }
    
    private AtomicBoolean mutex = new AtomicBoolean(false);
    
    @Override
    public void lock() {
        // 增加回退对象
        Backoff backoff = new Backoff(MIN_DELAY, MAX_DELAY);
        while(true){
            // 第一步使用读操作，尝试获取锁，当mutex为false时退出循环，表示可以获取锁
            while(mutex.get()){}
            // 第二部使用getAndSet方法来尝试获取锁
            if(!mutex.getAndSet(true)){
                return;
            }else{
                //回退
                try {
                    backoff.backoff();
                } catch (InterruptedException e) {
                }
            }    
            
        }
    }

    @Override
    public void unlock() {
        mutex.set(false);
    }

    public String toString(){
        return "TTASLock";
    }
}

 

回退自旋锁的问题是回退的时间难以控制，需要不断测试才能找到合适的值，而且依赖底层硬件的性能，扩展性差。后面会有更好的自旋锁实现算法。

下面我们测试一下TASLock和TTASLock的性能。

首先写一个计时的类

[java] view plain copy print?

1. package com.test.lock;  
2.   
3. public class TimeCost implements Lock{  
4.   
5.     private final Lock lock;  
6.       
7.     public TimeCost(Lock lock){  
8.         this.lock = lock;  
9.     }  
10.       
11.     @Override  
12.     public void lock() {  
13.         long start = System.nanoTime();  
14.         lock.lock();  
15.         long duration = System.nanoTime() - start;  
16.         System.out.println(lock.toString() + " time cost is " + duration +  " ns");  
17.     }  
18.   
19.     @Override  
20.     public void unlock() {  
21.         lock.unlock();  
22.     }  
23.   
24. }  

package com.test.lock;

public class TimeCost implements Lock{

	private final Lock lock;
	
	public TimeCost(Lock lock){
		this.lock = lock;
	}
	
	@Override
	public void lock() {
		long start = System.nanoTime();
		lock.lock();
		long duration = System.nanoTime() - start;
		System.out.println(lock.toString() + " time cost is " + duration + " ns");
	}

	@Override
	public void unlock() {
		lock.unlock();
	}

}

然后采用多个线程来模拟对同一把锁的争用 [java] view plain copy print?

1. package com.test.lock;  
2.   
3. public class Main {  
4.     private static TimeCost timeCost = new TimeCost( new TASLock());  
5.       
6.     //private static TimeCost timeCost = new TimeCost(new TTASLock());  
7.       
8.     public static void method(){  
9.         timeCost.lock();  
10.         //int a = 10;  
11.         timeCost.unlock();  
12.     }  
13.       
14.     public static void main(String[] args) {  
15.         for(int i = 0; i <  100; i ++){  
16.             Thread t = new Thread(new Runnable(){  
17.       
18.                 @Override  
19.                 public void run() {  
20.                     method();  
21.                 }  
22.                   
23.             });  
24.             t.start();  
25.         }  
26.     }  
27.   
28. }  

package com.test.lock;

public class Main {
	private static TimeCost timeCost = new TimeCost(new TASLock());
	
	//private static TimeCost timeCost = new TimeCost(new TTASLock());
	
	public static void method(){
		timeCost.lock();
		//int a = 10;
		timeCost.unlock();
	}
	
	public static void main(String[] args) {
		for(int i = 0; i < 100; i ++){
			Thread t = new Thread(new Runnable(){
	
				@Override
				public void run() {
					method();
				}
				
			});
			t.start();
		}
	}

}

测试机器的性能如下：

CPU： 4  Intel(R) Core(TM) i3-2120 CPU @ 3.30GHz

内存： 8G

测试结果：

50个线程情况下：

TASLock平均获取锁的时间： 339715 ns

TTASLock平均获取锁的时间： 67106.2 ns

100个线程情况下：

TASLock平均获取锁的时间： 1198413 ns

TTASLock平均获取锁的时间： 1273588 ns

可以看到TTASLock的性能比TASLock的性能更好

转载请注明来源: blog.csdn.net/iter_zc