1. Java语言监视器上的原子锁定
2. Java语言监视器上的偏向锁定
3. Java 5中随java.util.concurrent包引入的ReentrantLock 。

代码

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.CyclicBarrier;import static java.lang.System.out;public final class TestLocks implements Runnable
{public enum LockType { JVM, JUC }public static LockType lockType;public static final long ITERATIONS = 500L * 1000L *1000L;public static long counter = 0L;public static final Object jvmLock = new Object();public static final Lock jucLock = new ReentrantLock();private static int numThreads;private static CyclicBarrier barrier;public static void main(final String[] args) throws Exception{lockType = LockType.valueOf(args[0]);numThreads = Integer.parseInt(args[1]);runTest(numThreads); // warm upcounter = 0L;final long start = System.nanoTime();runTest(numThreads);final long duration = System.nanoTime() - start;out.printf("%d threads, duration %,d (ns)\n", numThreads, duration);out.printf("%,d ns/op\n", duration / ITERATIONS);out.printf("%,d ops/s\n", (ITERATIONS * 1000000000L) / duration);out.println("counter = " + counter);}private static void runTest(final int numThreads) throws Exception{barrier = new CyclicBarrier(numThreads);Thread[] threads = new Thread[numThreads];for (int i = 0; i < threads.length; i++){threads[i] = new Thread(new TestLocks());}for (Thread t : threads){t.start();}for (Thread t : threads){t.join();}}public void run(){try{barrier.await();}catch (Exception e){// don't care}switch (lockType){case JVM: jvmLockInc(); break;case JUC: jucLockInc(); break;}}private void jvmLockInc(){long count = ITERATIONS / numThreads;while (0 != count--){synchronized (jvmLock){++counter;}}}private void jucLockInc(){long count = ITERATIONS / numThreads;while (0 != count--){jucLock.lock();try{++counter;}finally{jucLock.unlock();}}}
}

编写测试脚本：

设置-x
对于{1..8}中的i； 做Java -XX：-UseBiasedLocking TestLocks JVM $ i; 做完了
对于{1..8}中的i； 做Java -XX：+ UseBiasedLocking TestLocks JVM $ i; 做完了 对于{1..8}中的i； 做Java TestLocks JUC $ i; 做完了

结果

图1

图2

图3

1. 在无竞争的情况下，有偏锁比原子锁贵10％。 似乎对于最近的CPU代来说，原子指令的成本比偏向锁的必要内务处理要少。 在Nehalem之前，锁定指令会在内存总线上声明一个锁定以执行这些原子操作，每个操作都将花费100个以上的周期。 从Nehalem开始，原子指令可以在CPU内核本地进行处理，并且在执行内存排序语义时不需要等待存储缓冲区为空时，通常只需花费10-20个周期。
2. 随着争用的增加，无论线程数如何，语言监视器锁定都会Swift达到吞吐量限制。
3. 与使用同步的语言监视器相比，ReentrantLock提供了最佳的无竞争性能，并且随着争用的增加，扩展性也显着提高。
4. 当2个线程竞争时，ReentrantLock具有降低性能的奇怪特征。 这值得进一步调查。
5. 当竞争线程数较少时，Sandybridge遭受原子指令增加的延迟 ，这在上一篇文章中已详细介绍。 随着竞争线程数的不断增加，内核仲裁的成本趋于占主导地位，而Sandybridge在提高内存吞吐量方面显示出其优势。