The art of multipropcessor programming 读书笔记-3. 自旋锁与争用(1)

public class Backoff {
	private final long minDelay;
	private final long maxDelay;
	private long current;

	public Backoff(long minDelay, long maxDelay) {
		this.minDelay = minDelay;
		this.maxDelay = maxDelay;
		//初始随机最大为 minDelay
		this.current = minDelay;
	}

	public void backoff() {
		//使用 ThreadLocalRandom 防止并发影响随机
		long delay = ThreadLocalRandom.current().nextLong(1, current);
		//随着次数翻倍，直到 maxDelay
		current = Math.min(current * 2L, maxDelay);
		try {
			Thread.sleep(delay);
		} catch (InterruptedException e) {
			//ignore
		}
	}
}

复制代码

public class TTASWithBackoffLock implements Lock {
	private boolean locked = false;
	private final Backoff backoff = new Backoff(10L, 100L);
	//操作 locked 的句柄
	private static final VarHandle LOCKED;
	static {
		try {
			//初始化句柄
			LOCKED = MethodHandles.lookup().findVarHandle(TTASWithBackoffLock.class, "locked", boolean.class);
		} catch (Exception e) {
			throw new Error(e);
		}
	}

	@Override
	public void lock() {
		while (true) {
			//普通读取 locked，如果被占用，则一直 SPIN
			while ((boolean) LOCKED.get(this)) {
				//让出 CPU 资源，这是目前实现 SPIN 效果最好的让出 CPU 的方式，当线程数量远大于 CPU 数量时，效果比 Thread.yield 好，从及时性角度效果远好于 Thread.sleep
				Thread.onSpinWait();
			}
			//成功代表获取了锁
			if (LOCKED.compareAndSet(this, false, true)) {
				return;
			} else {
				//失败则回退
				backoff.backoff();
			}
		}
	}

	@Override
	public void unlock() {
		LOCKED.setVolatile(this, false);
	}
}
复制代码

//测试指标为单次调用时间
@BenchmarkMode(Mode.SingleShotTime)
//需要预热，排除 jit 即时编译以及 JVM 采集各种指标带来的影响，由于我们单次循环很多次，所以预热一次就行
@Warmup(iterations = 1)
//单线程即可
@Fork(1)
//测试次数，我们测试10次
@Measurement(iterations = 10)
//定义了一个类实例的生命周期，所有测试线程共享一个实例
@State(value = Scope.Benchmark)
public class LockTest {
	private static class ValueHolder {
		int count = 0;
	}

	//测试不同线程数量
	@Param(value = {"1", "2", "5", "10", "20", "50", "100"})
	private int threadsCount;

	@Benchmark
	public void testTTASWithBackoffLock(Blackhole blackhole) throws InterruptedException {
		test(new TTASWithBackoffLock());
	}

	@Benchmark
	public void testTTASLock(Blackhole blackhole) throws InterruptedException {
		test(new TTASLock());
	}

	private void test(Lock lock) throws InterruptedException {
		ValueHolder valueHolder = new ValueHolder();
		Thread[] threads = new Thread[threadsCount];
		//测试累加 5000000 次
		for (int i = 0; i < threads.length; i++) {
			threads[i] = new Thread(() -> {
				for (int j = 0; j < 5000000 / threads.length; j++) {
					lock.lock();
					try {
						valueHolder.count++;
					} finally {
						lock.unlock();
					}
				}
			});
			threads[i].start();
		}
		for (int i = 0; i < threads.length; i++) {
			threads[i].join();
		}
		if (valueHolder.count != 5000000) {
			throw new RuntimeException("something wrong in lock implementation");
		}
	}

	public static void main(String[] args) throws RunnerException {
		Options opt = new OptionsBuilder().include(LockTest.class.getSimpleName()).build();
		new Runner(opt).run();
	}
}

复制代码

Benchmark                         (threadsCount)  Mode  Cnt  Score   Error  Units
LockTest.testTTASLock                          1    ss   10  0.064 ± 0.005   s/op
LockTest.testTTASLock                          2    ss   10  0.138 ± 0.044   s/op
LockTest.testTTASLock                          5    ss   10  0.426 ± 0.100   s/op
LockTest.testTTASLock                         10    ss   10  0.699 ± 0.128   s/op
LockTest.testTTASLock                         20    ss   10  0.932 ± 0.241   s/op
LockTest.testTTASLock                         50    ss   10  1.162 ± 0.542   s/op
LockTest.testTTASLock                        100    ss   10  1.379 ± 0.939   s/op
LockTest.testTTASWithBackoffLock               1    ss   10  0.068 ± 0.008   s/op
LockTest.testTTASWithBackoffLock               2    ss   10  0.080 ± 0.023   s/op
LockTest.testTTASWithBackoffLock               5    ss   10  0.135 ± 0.037   s/op
LockTest.testTTASWithBackoffLock              10    ss   10  0.187 ± 0.072   s/op
LockTest.testTTASWithBackoffLock              20    ss   10  0.200 ± 0.063   s/op
LockTest.testTTASWithBackoffLock              50    ss   10  0.239 ± 0.052   s/op
LockTest.testTTASWithBackoffLock             100    ss   10  0.261 ± 0.042   s/op

Process finished with exit code 0

复制代码