synchronized & ReentrantLock 的一点疑问
经过JDK1.6对synchronized的进一步优化，通常情况下，synchronized与lock & unlock 效率差别不大，如果大家做一下简单实验应该不容易得出，见http://www.blogjava.net/killme2008/archive/2007/09/14/145195.html中的实验，但在做下面这个实验时，发现两者效率上还是有些区别的。
这是一个最简单的阻塞队列的实现，分别采用synchronized和ReentrantLock来实现，代码如下：
public interface Queue<E> { public void put(E e); public E take() throws InterruptedException;}import java.util.LinkedList;public class RawSyncQueue<E> implements Queue<E> { private LinkedList<E> queue = new LinkedList<E>(); public synchronized void put(E e) { if (queue.size() == 0) { notifyAll(); } queue.add(e); } public synchronized E take() throws InterruptedException { for (;;) { if (queue.size() == 0) { wait(); } if (queue.size() != 0) { return queue.remove(0); } } }}import java.util.LinkedList;import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class LockSyncQueue<E> implements Queue<E> { private Lock lock = new ReentrantLock(); private Condition notEmpty = lock.newCondition(); private LinkedList<E> queue = new LinkedList<E>(); public void put(E e) { lock.lock(); if (queue.size() == 0) { notEmpty.signalAll(); } queue.add(e); lock.unlock(); } public E take() throws InterruptedException { lock.lock(); for (;;) { if (queue.size() == 0) { notEmpty.await(); } if (queue.size() != 0) { E result = queue.remove(0); lock.unlock(); return result; } } }}采用下面的方式来进行测试：
import java.util.concurrent.CyclicBarrier;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.atomic.AtomicInteger;public class PuterTakerTest { private static final ExecutorService pool = Executors.newCachedThreadPool(); private final AtomicInteger putSum = new AtomicInteger(0); private final AtomicInteger takeSum = new AtomicInteger(0); private final CyclicBarrier barrier; private final Queue<Integer> bq; private final int nTrials, nPairs; public static void testAll(int nParis, int tpt) throws Exception { System.out.println(nParis + ", " + tpt); System.out.print("RawSyncQueue: "); Queue<Integer> rawSyncQueue = new RawSyncQueue<Integer>(); new PuterTakerTest(rawSyncQueue, nParis, tpt).test(); System.out.print("LockSyncQueue: "); Queue<Integer> lockSyncQueue = new LockSyncQueue<Integer>(); new PuterTakerTest(lockSyncQueue, nParis, tpt).test(); } public static void testAll(int... params) throws Exception { if (params.length != 2) { throw new IllegalArgumentException(); } testAll(params[0], params[1]); } public static void main(String[] args) throws Exception { int[] params = new int[0]; params = new int[] { 1, 100000 }; testAll(params); params = new int[] { 2, 100000 }; testAll(params); params = new int[] { 4, 100000 }; testAll(params); params = new int[] { 8, 100000 }; testAll(params); params = new int[] { 16, 100000 }; testAll(params); params = new int[] { 32, 100000 }; testAll(params); params = new int[] { 1, 1000000 }; testAll(params); params = new int[] { 2, 1000000 }; testAll(params); params = new int[] { 4, 1000000 }; testAll(params); params = new int[] { 8, 1000000 }; testAll(params); params = new int[] { 16, 1000000 }; testAll(params); params = new int[] { 32, 1000000 }; testAll(params); pool.shutdown(); } PuterTakerTest(Queue<Integer> queue, int nPairs, int nTrials) throws Exception{ this.bq = queue; this.nTrials = nTrials; this.nPairs = nPairs; this.barrier = new CyclicBarrier(nPairs * 2 + 1); } public void test() { try { for (int i = 0; i < nPairs; ++i) { pool.execute(new Producer()); pool.execute(new Consumer()); } long startTime = System.nanoTime(); barrier.await(); barrier.await(); long nsPerItem = (System.nanoTime() - startTime) / (nPairs * (long) nTrials); System.out.println("Throughput: " + nsPerItem + " ns/item"); assertEquals(putSum.get(), takeSum.get()); } catch (Exception e) { throw new RuntimeException(e); } } private static void assertEquals(int a, int b) { if (a != b) { throw new RuntimeException(a + " is not equals " + b); } } private static int xorShift(int seed) { seed ^= seed << 6; seed ^= seed >>> 21; seed ^= (seed << 7); return seed; } class Producer implements Runnable { @Override public void run() { try { int seed = (this.hashCode() ^ (int) System.nanoTime()); int sum = 0; barrier.await(); for (int i = nTrials; i > 0; --i) { bq.put(seed); sum += seed; seed = xorShift(seed); } putSum.getAndAdd(sum); barrier.await(); } catch (Exception e) { throw new RuntimeException(e); } } } class Consumer implements Runnable { @Override public void run() { try { barrier.await(); int sum = 0; for (int i = nTrials; i > 0; --i) { sum += bq.take(); } takeSum.getAndAdd(sum); barrier.await(); } catch (Exception e) { throw new RuntimeException(e); } } }}上面这个实验的结果这里就不贴了，欢迎大家去实验。
做过http://www.blogjava.net/killme2008/archive/2007/09/14/145195.html这个实验的同学应该不容易发现，如果只采用lock&unlock与synchronized差别的确不大。
所以我只能妄断是条件signalAll&await的功劳，或许因为试验方式不对，或者的确是因为这个原因，终究我还没弄透。
signalAll&await的实现原理,这里有些讲解http://www.goldendoc.org/2011/06/juc_condition/