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則顯示出其在提高內存吞吐量方面的優勢。