通过ExecutorService实现单例的同步访问控制

from:http://www.java2000.net/p13007

Count是一个多线程偶数计数器，通常我们应该使用synchronized，或者Lock来保证该递增操作的原子性和可见性。本例使用了单例的ExecutorService，来保证Count的递增的原子性。

1. import java.util.concurrent.Callable;
2. import java.util.concurrent.ExecutionException;
3. import java.util.concurrent.ExecutorService;
4. import java.util.concurrent.Executors;
6. /**
7.  * 通过ExecutorService实现单例的同步访问控制。
8.  * 
9.  * @author 老紫竹 JAVA世纪网(java2000.net)
10.  * 
11.  */
12. public class T {
13.   private final ExecutorService exec = Executors.newSingleThreadExecutor();
15.   public long getCount() throws InterruptedException, ExecutionException {
16.     return exec.submit(new Callable<Long>() {
17.       @Override
18.       public Long call() throws Exception {
19.         return ++count;
20.       }
21.     }).get();
22.   }
24.   private long count;
26.   public void add() {
27.     exec.execute(new Runnable() {
28.       @Override
29.       public void run() {
30.         count++;
31.         System.out.println(count);
32.       }
33.     });
34.   }
36.   public static void main(String[] args) {
37.     final T t = new T();
38.     class TT extends Thread {
39.       public void run() {
40.         for (int i = 1; i <= 5; i++) {
41.           try {
42.             t.add();
43.             System.out.println(t.getCount());
44.             Thread.sleep(10);
45.           } catch (Exception e) {
46.             // TODO Auto-generated catch block
47.             e.printStackTrace();
48.           }
49.         }
50.       }
51.     }
52.     for (int i = 1; i <= 5; i++) {
53.       new TT().start();
54.     }
55.   }
56. }

运行结果
1
2
3
4
5
6
7
10
8
9
11
12
15
16
19
14
17
20
13
18
21
22
24
26
28
25
29
27
30
23
31
32
35
37
39
33
36
38
34
40
41
42
45
47
49
43
44
46
48
50