Java并发编程实践 目录

并发编程 01—— ThreadLocal

并发编程 02—— ConcurrentHashMap

并发编程 03—— 阻塞队列和生产者-消费者模式

并发编程 04—— 闭锁CountDownLatch 与 栅栏CyclicBarrier

并发编程 05—— Callable和Future

并发编程 06—— CompletionService : Executor 和 BlockingQueue

并发编程 07—— 任务取消

并发编程 08—— 任务取消 之 中断

并发编程 09—— 任务取消 之 停止基于线程的服务

并发编程 10—— 任务取消 之 关闭 ExecutorService

并发编程 11—— 任务取消 之 “毒丸”对象

并发编程 12—— 任务取消与关闭 之 shutdownNow 的局限性

并发编程 13—— 线程池的使用 之 配置ThreadPoolExecutor 和 饱和策略

并发编程 14—— 线程池 之 整体架构

并发编程 15—— 线程池 之 原理一

并发编程 16—— 线程池 之 原理二

并发编程 17—— Lock

并发编程 18—— 使用内置条件队列实现简单的有界缓存

并发编程 19—— 显式的Conditon 对象

并发编程 20—— AbstractQueuedSynchronizer 深入分析

并发编程 21—— 原子变量和非阻塞同步机制

 1 package com.concurrency.CancellationAndShutdown_7;
 2
 3 import java.math.BigInteger;
 4 import java.util.ArrayList;
 5 import java.util.List;
 6
 7 import net.jcip.annotations.GuardedBy;
 8
 9 /**
10  * 使用volatile 类型的域来保存取消状态
11  * @ClassName: PrimeGenerator
12  * @author Xingle
13  * @date 2014-9-24 下午3:05:08
14  */
15 public class PrimeGenerator implements Runnable{
16
17     @GuardedBy("this")
18     private final List<BigInteger> primes = new ArrayList<BigInteger>();
19
20     private volatile boolean cancelled;
21
22     @Override
23     public void run() {
24         BigInteger p = BigInteger.ONE;
25         while(!cancelled){
26             //返回下一个大于p的素数
27             p = p.nextProbablePrime();
28             synchronized (this) {
29                 primes.add(p);
30
31             }
32         }
33     }
34
35     public void cancel(){
36         cancelled = true;
37     }
38
39     public synchronized List<BigInteger> get(){
40         return new ArrayList<BigInteger>(primes);
41     }
42
43 }

 1 package com.concurrency.CancellationAndShutdown_7;
 2
 3 import java.math.BigInteger;
 4 import java.util.List;
 5
 6
 7 /**
 8  * 测试程序—— 运行100ms时间的素数生成器
 9  * @ClassName: PrimeGeneratorMain
10  * @author Xingle
11  * @date 2014-9-24 下午5:23:44
12  */
13 public class PrimeGeneratorMain {
14
15     public static void main(String[] args){
16         PrimeGenerator generator = new PrimeGenerator();
17         new Thread(generator).start();
18         try {
19             Thread.sleep(100);
20         } catch (InterruptedException e) {
21             e.printStackTrace();
22         } finally {
23             generator.cancel();
24         }
25         List<BigInteger> ls = generator.get();
26         for(int i= 0;i<ls.size();i++){
27             System.out.println(ls.get(i));
28         }
29     }
30 }