各种同步方法性能比较（synchronized,ReentrantLock,Atomic）

为什么80%的码农都做不了架构师&＃xff1f;>>>

为了比较一下ReentrantLock和synchronized的性能&＃xff0c;做了一下性能测试&＃xff1a;

得出结论&＃xff1a;

&＃xff08;1&＃xff09;使用Lock的性能比使用synchronized关键字要提高4~5倍&＃xff1b;

&＃xff08;2&＃xff09;使用信号量实现同步的速度大约比synchronized要慢10~20%&＃xff1b;

&＃xff08;3&＃xff09;使用atomic包的AtomicInter速度是比Lock要快1一个数量级。

ReentrantLock 类
java.util.concurrent.lock 中的 Lock 框架是锁定的一个抽象&＃xff0c;它允许把锁定的实现作为 Java 类&＃xff0c;而不是作为语言的特性来实现。这就为 Lock 的多种实现留下了空间&＃xff0c;各种实现可能有不同的调度算法、性能特性或者锁定语义。ReentrantLock 类实现了 Lock&＃xff0c;它拥有与 synchronized 相同的并发性和内存语义&＃xff0c;但是添加了类似锁投票、定时锁等候和可中断锁等候的一些特性。此外&＃xff0c;它还提供了在激烈争用情况下更佳的性能。&＃xff08;换句话说&＃xff0c;当许多线程都想访问共享资源时&＃xff0c;JVM 可以花更少的时候来调度线程&＃xff0c;把更多时间用在执行线程上。&＃xff09;

reentrant 锁意味着什么呢&＃xff1f;简单来说&＃xff0c;它有一个与锁相关的获取计数器&＃xff0c;如果拥有锁的某个线程再次得到锁&＃xff0c;那么获取计数器就加1&＃xff0c;然后锁需要被释放两次才能获得真正释放。这模仿了 synchronized 的语义&＃xff1b;如果线程进入由线程已经拥有的监控器保护的 synchronized 块&＃xff0c;就允许线程继续进行&＃xff0c;当线程退出第二个&＃xff08;或者后续&＃xff09;synchronized 块的时候&＃xff0c;不释放锁&＃xff0c;只有线程退出它进入的监控器保护的第一个 synchronized 块时&＃xff0c;才释放锁。

在查看清单 1 中的代码示例时&＃xff0c;可以看到 Lock 和 synchronized 有一点明显的区别 —— lock 必须在 finally 块中释放。否则&＃xff0c;如果受保护的代码将抛出异常&＃xff0c;锁就有可能永远得不到释放&＃xff01;这一点区别看起来可能没什么&＃xff0c;但是实际上&＃xff0c;它极为重要。忘记在 finally 块中释放锁&＃xff0c;可能会在程序中留下一个定时bomb&＃xff0c;当有一天bomb爆炸时&＃xff0c;您要花费很大力气才有找到源头在哪。而使用同步&＃xff0c;JVM 将确保锁会获得自动释放。

Test的源码

view plaincopy to clipboardprint?
01.public abstract class Test {
02.    protected String id;
03.    protected CyclicBarrier barrier;
04.    protected long count;
05.    protected int threadNum;
06.    protected ExecutorService executor;
07.
08.    public Test(String id, CyclicBarrier barrier, long count, int threadNum,
09.            ExecutorService executor) {
10.        this.id &＃61; id;
11.        this.barrier &＃61; barrier;
12.        this.count &＃61; count;
13.        this.threadNum &＃61; threadNum;
14.        this.executor &＃61; executor;
15.    }
16.
17.    public void startTest() {
18.
19.        long start &＃61; System.currentTimeMillis();
20.
21.        for (int j &＃61; 0; j 22.            executor.execute(new Thread() {
23.                &＃64;Override
24.                public void run() {
25.                    for (int i &＃61; 0; i 26.                        test();
27.                    }
28.
29.                    try {
30.                        barrier.await();
31.
32.                    } catch (InterruptedException e) {
33.                        e.printStackTrace();
34.                    } catch (BrokenBarrierException e) {
35.                        e.printStackTrace();
36.                    }
37.                }
38.            });
39.        }
40.
41.        try {
42.            barrier.await();
43.        } catch (InterruptedException e) {
44.            e.printStackTrace();
45.        } catch (BrokenBarrierException e) {
46.            e.printStackTrace();
47.        }
48.
49.        // 所有线程执行完成之后&＃xff0c;才会跑到这一步
50.        long duration &＃61; System.currentTimeMillis() - start;
51.        System.out.println(id &＃43; " &＃61; " &＃43; duration);
52.    }
53.
54.    protected abstract void test();
55.}
public abstract class Test {
protected String id;
protected CyclicBarrier barrier;
protected long count;
protected int threadNum;
protected ExecutorService executor;

public Test(String id, CyclicBarrier barrier, long count, int threadNum,
   ExecutorService executor) {
  this.id &＃61; id;
  this.barrier &＃61; barrier;
  this.count &＃61; count;
  this.threadNum &＃61; threadNum;
  this.executor &＃61; executor;
}

public void startTest() {

long start &＃61; System.currentTimeMillis();

  for (int j &＃61; 0; j    executor.execute(new Thread() {
    &＃64;Override
    public void run() {
     for (int i &＃61; 0; i       test();
     }

try {
barrier.await();

     } catch (InterruptedException e) {
      e.printStackTrace();
     } catch (BrokenBarrierException e) {
      e.printStackTrace();
     }
    }
   });
  }

  try {
   barrier.await();
  } catch (InterruptedException e) {
   e.printStackTrace();
  } catch (BrokenBarrierException e) {
   e.printStackTrace();
  }

  // 所有线程执行完成之后&＃xff0c;才会跑到这一步
  long duration &＃61; System.currentTimeMillis() - start;
  System.out.println(id &＃43; " &＃61; " &＃43; duration);
}

protected abstract void test();
}

测试类ReentreLockTest 源码

view plaincopy to clipboardprint?
01.import thread.test.Test;
02.
03.public class ReentreLockTest {
04.    private static long COUNT &＃61; 1000000;
05.    private static Lock lock &＃61; new ReentrantLock();
06.    private static long lockCounter &＃61; 0;
07.    private static long syncCounter &＃61; 0;
08.    private static long semaCounter &＃61; 0;
09.    private static AtomicLong atomicCounter &＃61; new AtomicLong(0);
10.    private static Object syncLock &＃61; new Object();
11.    private static Semaphore mutex &＃61; new Semaphore(1);
12.
13.    public static void testLock(int num, int threadCount) {
14.
15.    }
16.
17.    static long getLock() {
18.        lock.lock();
19.        try {
20.            return lockCounter;
21.        } finally {
22.            lock.unlock();
23.        }
24.    }
25.
26.    static long getSync() {
27.        synchronized (syncLock) {
28.            return syncCounter;
29.        }
30.    }
31.
32.    static long getAtom() {
33.        return atomicCounter.get();
34.    }
35.
36.    static long getSemaphore() throws InterruptedException {
37.        mutex.acquire();
38.
39.        try {
40.            return semaCounter;
41.        } finally {
42.            mutex.release();
43.        }
44.    }
45.
46.    static long getLockInc() {
47.        lock.lock();
48.        try {
49.            return &＃43;&＃43;lockCounter;
50.        } finally {
51.            lock.unlock();
52.        }
53.    }
54.
55.    static long getSyncInc() {
56.        synchronized (syncLock) {
57.            return &＃43;&＃43;syncCounter;
58.        }
59.    }
60.
61.    static long getAtomInc() {
62.        return atomicCounter.getAndIncrement();
63.    }
64.
65.    static class SemaTest extends Test {
66.
67.        public SemaTest(String id, CyclicBarrier barrier, long count,
68.                int threadNum, ExecutorService executor) {
69.            super(id, barrier, count, threadNum, executor);
70.        }
71.
72.        &＃64;Override
73.        protected void test() {
74.            try {
75.                getSemaphore();
76.            } catch (InterruptedException e) {
77.                e.printStackTrace();
78.            }
79.        }
80.
81.    }
82.
83.    static class LockTest extends Test {
84.
85.        public LockTest(String id, CyclicBarrier barrier, long count,
86.                int threadNum, ExecutorService executor) {
87.            super(id, barrier, count, threadNum, executor);
88.        }
89.
90.        &＃64;Override
91.        protected void test() {
92.            getLock();
93.        }
94.
95.    }
96.
97.    static class SyncTest extends Test {
98.
99.        public SyncTest(String id, CyclicBarrier barrier, long count,
100.                int threadNum, ExecutorService executor) {
101.            super(id, barrier, count, threadNum, executor);
102.        }
103.
104.        &＃64;Override
105.        protected void test() {
106.            getSync();
107.        }
108.
109.    }
110.
111.    static class AtomicTest extends Test {
112.
113.        public AtomicTest(String id, CyclicBarrier barrier, long count,
114.                int threadNum, ExecutorService executor) {
115.            super(id, barrier, count, threadNum, executor);
116.        }
117.
118.        &＃64;Override
119.        protected void test() {
120.            getAtom();
121.        }
122.
123.    }
124.
125.    public static void test(String id, long count, int threadNum,
126.            ExecutorService executor) {
127.
128.        final CyclicBarrier barrier &＃61; new CyclicBarrier(threadNum &＃43; 1,
129.                new Thread() {
130.
131.                    &＃64;Override
132.                    public void run() {
133.
134.                    }
135.                });
136.
137.        System.out.println("&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;");
138.        System.out.println("count &＃61; " &＃43; count &＃43; "\t" &＃43; "Thread Count &＃61; "
139.                &＃43; threadNum);
140.
141.        new LockTest("Lock ", barrier, COUNT, threadNum, executor).startTest();
142.        new SyncTest("Sync ", barrier, COUNT, threadNum, executor).startTest();
143.        new AtomicTest("Atom ", barrier, COUNT, threadNum, executor)
144.                .startTest();
145.        new SemaTest("Sema ", barrier, COUNT, threadNum, executor)
146.                .startTest();
147.        System.out.println("&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;");
148.    }
149.
150.    public static void main(String[] args) {
151.        for (int i &＃61; 1; i <5; i&＃43;&＃43;) {
152.            ExecutorService executor &＃61; Executors.newFixedThreadPool(10 * i);
153.            test("", COUNT * i, 10 * i, executor);
154.        }
155.    }
156.}
import thread.test.Test;

public class ReentreLockTest {
private static long COUNT &＃61; 1000000;
private static Lock lock &＃61; new ReentrantLock();
private static long lockCounter &＃61; 0;
private static long syncCounter &＃61; 0;
private static long semaCounter &＃61; 0;
private static AtomicLong atomicCounter &＃61; new AtomicLong(0);
private static Object syncLock &＃61; new Object();
private static Semaphore mutex &＃61; new Semaphore(1);

public static void testLock(int num, int threadCount) {

}

static long getLock() {
  lock.lock();
  try {
   return lockCounter;
  } finally {
   lock.unlock();
  }
}

static long getSync() {
  synchronized (syncLock) {
   return syncCounter;
  }
}

static long getAtom() {
return atomicCounter.get();
}

static long getSemaphore() throws InterruptedException {
mutex.acquire();

  try {
   return semaCounter;
  } finally {
   mutex.release();
  }
}

static long getLockInc() {
  lock.lock();
  try {
   return &＃43;&＃43;lockCounter;
  } finally {
   lock.unlock();
  }
}

static long getSyncInc() {
  synchronized (syncLock) {
   return &＃43;&＃43;syncCounter;
  }
}

static long getAtomInc() {
return atomicCounter.getAndIncrement();
}

static class SemaTest extends Test {

  public SemaTest(String id, CyclicBarrier barrier, long count,
    int threadNum, ExecutorService executor) {
   super(id, barrier, count, threadNum, executor);
  }

  &＃64;Override
  protected void test() {
   try {
    getSemaphore();
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }

}

static class LockTest extends Test {

  public LockTest(String id, CyclicBarrier barrier, long count,
    int threadNum, ExecutorService executor) {
   super(id, barrier, count, threadNum, executor);
  }

  &＃64;Override
  protected void test() {
   getLock();
  }

}

static class SyncTest extends Test {

  public SyncTest(String id, CyclicBarrier barrier, long count,
    int threadNum, ExecutorService executor) {
   super(id, barrier, count, threadNum, executor);
  }

  &＃64;Override
  protected void test() {
   getSync();
  }

}

static class AtomicTest extends Test {

  public AtomicTest(String id, CyclicBarrier barrier, long count,
    int threadNum, ExecutorService executor) {
   super(id, barrier, count, threadNum, executor);
  }

  &＃64;Override
  protected void test() {
   getAtom();
  }

}

public static void test(String id, long count, int threadNum,
ExecutorService executor) {

final CyclicBarrier barrier &＃61; new CyclicBarrier(threadNum &＃43; 1,
new Thread() {

&＃64;Override
public void run() {

}
});

  System.out.println("&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;");
  System.out.println("count &＃61; " &＃43; count &＃43; "\t" &＃43; "Thread Count &＃61; "
    &＃43; threadNum);

  new LockTest("Lock ", barrier, COUNT, threadNum, executor).startTest();
  new SyncTest("Sync ", barrier, COUNT, threadNum, executor).startTest();
  new AtomicTest("Atom ", barrier, COUNT, threadNum, executor)
    .startTest();
  new SemaTest("Sema ", barrier, COUNT, threadNum, executor)
    .startTest();
  System.out.println("&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;");
}

public static void main(String[] args) {
  for (int i &＃61; 1; i <5; i&＃43;&＃43;) {
   ExecutorService executor &＃61; Executors.newFixedThreadPool(10 * i);
   test("", COUNT * i, 10 * i, executor);
  }
}
}

结果

view plaincopy to clipboardprint?
01.&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;
02.count &＃61; 1000000 Thread Count &＃61; 10
03.Lock &＃61; 953
04.Sync &＃61; 3781
05.Atom &＃61; 78
06.Sema &＃61; 4922
07.&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;
08.&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;
09.count &＃61; 2000000 Thread Count &＃61; 20
10.Lock &＃61; 1906
11.Sync &＃61; 8469
12.Atom &＃61; 172
13.Sema &＃61; 9719
14.&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;
15.&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;
16.count &＃61; 3000000 Thread Count &＃61; 30
17.Lock &＃61; 2890
18.Sync &＃61; 12641
19.Atom &＃61; 219
20.Sema &＃61; 15015
21.&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;
22.&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;
23.count &＃61; 4000000 Thread Count &＃61; 40
24.Lock &＃61; 3844
25.Sync &＃61; 17141
26.Atom &＃61; 343
27.Sema &＃61; 19782
28.&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;