Java 多线程高并发编程 笔记（二）

1. 单例模式（在内存之中永远只有一个对象）

1.1 多线程安全单例模式——不使用同步锁

1 public class Singleton {
2     private static Singleton sin=new Singleton();    ///直接初始化一个实例对象
3     private Singleton(){    ///private类型的构造函数，保证其他类对象不能直接new一个该对象的实例
4     }
5     public static Singleton getSin(){    ///该类唯一的一个public方法    
6         return sin;
7     }
8 }

　　上述代码中的一个缺点是该类加载的时候就会直接new 一个静态对象出来，当系统中这样的类较多时，会使得启动速度变慢 。现在流行的设计都是讲“延迟加载”，我们可以在第一次使用的时候才初始化第一个该类对象。所以这种适合在小系统。

1.2 多线程安全单例模式——使用同步方法

 1 public class Singleton {  
 2      private static Singleton instance;  
 3      private Singleton (){
 4          
 5      }   
 6      public static synchronized Singleton getInstance(){    //对获取实例的方法进行同步
 7        if (instance == null)     
 8          instance = new Singleton(); 
 9        return instance;
10      }
11  }

　　上述代码中的一次锁住了一个方法， 这个粒度有点大 ，改进就是只锁住其中的new语句就OK。就是所谓的“双重锁”机制。

1.3 多线程安全单例模式——使用双重同步锁

 1 public class Singleton {  
 2      private static Singleton instance;  
 3      private Singleton (){
 4      }   
 5      public static Singleton getInstance(){    //对获取实例的方法进行同步
 6        if (instance == null){
 7            synchronized(Singleton.class){
 8                if (instance == null)
 9                    instance = new Singleton(); 
10            }
11        }
12        return instance;
13      }
14      
15  }

1.4 多线程安全单例模式——使用内部类的单例模式

　　既不用加锁，也能实现懒加载

 1 public class Singleton {
 2     private Singleton(){
 3         System.out.println("single");
 4     }
 5     private static class Inner{
 6         private static Singleton s = new Singleton();
 7     }
 8     //无论有多少次，有多少个线程在调用getsingle的时候拿到的都是同一个对象
 9     private static Singleton getSingle(){
10         return Inner.s;
11     }
12     public static void main(String[] agrs){
13         Thread[] ths = new Thread[200];
14         for(int i=0; i){
15             ths[i]=new Thread(()->{
16                 Singleton.getSingle();
17             });
18         }
19         Arrays.asList(ths).forEach(o->o.start());
20     }
21 }

2. 高并发——容器

2.1 有N张火车票，每张票都有一个编号，同时有10个窗口对外售票，写一个模拟程序，分析可能会产生哪些问题？重复销售，超量销售；

 1 public class TicketSeller1 {
 2     static List tickets = new ArrayList<>();
 3     //初始化，放票
 4     static{
 5         for(int i=0; i<10000; i++)
 6             tickets.add("票编号："+i);
 7     }
 8 
 9     public static void main(String[] args){
10         //启动10个线程不断往外卖票
11         for(int i=0;i<10;i++){
12             new Thread(()->{
13                 while(tickets.size()>0){
14                     System.out.println("销售了--"+tickets.remove(0));
15                 }
16             }).start();
17         }
18     }
19 }

改成下面的代码还有问题吗？

 1 public class TicketSeller2 {
 2     //vector本身就是一个同步容器，它所有的方法都是加锁的
 3     static Vector tickets = new Vector<>();
 4     static{
 5         for(int i=0; i<10000; i++)
 6             tickets.add("票编号："+i);
 7     }
 8     public static void main(String[] args){
 9         for(int i=0; i<10; i++){
10             new Thread(()->{
11                 while(tickets.size()>0){
12                     /*
13                     try{
14                         TimeUnit.SECONDS.sleep(10);
15                     }catch(InterruptedException e){
16                         e.printStackTrace();
17                     }*/
18                     System.out.println("销售了--"+tickets.remove(0));
19                 }
20             }).start();
21         }
22     }
23 }

 

仍有问题，判断与操作分离了（虽然在vector中size和remove方法都是原子的）；

再改进：将判断和操作放到一个原子操作里面去

 1 public class TicketSeller3 {
 2     static List tickets = new ArrayList<>();
 3     static{
 4         for(int i=0; i<10000; i++)
 5             tickets.add("票编号："+i);
 6     }
 7 
 8     public static void main(String[] args){
 9         //启动10个线程不断往外卖票
10         for(int i=0;i<10;i++){
11             new Thread(()->{
12                 while(true){
13                     synchronized (tickets){
14                         if(tickets.size()<=0) break;
15                         try{
16                             TimeUnit.SECONDS.sleep(10);
17                         }catch(InterruptedException e){
18                             e.printStackTrace();
19                         }
20 
21                         System.out.println("销售了--"+tickets.remove(0));
22                     }
23                 }
24             }).start();
25         }
26     }
27 }

加锁效率不高，尤其是每销售一张票都要把整个队列给锁定；

引入并发容器：

 1 public class TicketSeller4 {
 2     //并发容器
 3     static Queue tickets = new ConcurrentLinkedQueue<>();
 4     static{
 5         for(int i=0; i<1000; i++){
 6             tickets.add("票编号："+i);
 7         }
 8     }
 9     public static void main(String[] args){
10         for(int i=0; i<10; i++){
11             new Thread(()->{
12                 while(true){
13                     //poll从头往外拿一个数据，是同步的
14                     String s = tickets.poll();
15                     if(s==null) break;
16                     else System.out.println("销售了--"+s);
17                 }
18             }).start();
19         }
20     }
21 }

if(s==null) break;虽然不是原子性的，但是我们判断以后没有对队列作修改操作，所以这里不会出错。

2.2 并发容器————ConcurrentMap
在多线程的情况下，什么样的容器效率比较高？

 1 public class T_ConcurrentMap {
 2     public static void main(String[] args){
 3         //Map map = new ConcurrentHashMap<>();
 4         //Map map = new ConcurrentSkipListMap<>();
 5         //HashTable 默认加锁，但是效率比较低
 6         Map map = new Hashtable<>();
 7         //使用HashMap，自己往上加锁：Collection.synchronizedXXX
 8         //Map map = new HashMap<>();
 9         //Map map = new TreeMap<>();
10 
11         Random r = new Random();
12         Thread[] ths = new Thread[100];
13         CountDownLatch latch = new CountDownLatch(ths.length);
14         long start = System.currentTimeMillis();
15         for(int i=0; i){
16             ths[i] = new Thread(()->{
17                 for(int j=0; j<10000; j++)
18                     map.put("a"+r.nextInt(100000),"a"+r.nextInt(100000));
19                 latch.countDown();
20             });
21         }
22         Arrays.asList(ths).forEach(o->o.start());
23         try{
24             latch.await();
25         }catch (InterruptedException e){
26             e.printStackTrace();
27         }
28 
29         long end = System.currentTimeMillis();
30         System.out.println(end-start);
31     }
32 }

HashTable：669；

ConcurrentHashMap:391;

why? HashTable 往里加任何一个数据的时候都是要锁定整个对象，而HashMap，ConcurrentHashMap默认把容器分成16段，每次往容器里插数据只锁定16段里面的一段（把锁细化），两个线程往里插不同的段的数据，那么这两个线程就能并发的插入；

ConcurrentSkipListMap：649  高并发并且排序

往里插数据效率低一些，因为要排序，查数据方便很多；

总结：

　　1. 对于map/set的选择使用

　　　　不加锁：hashmap；treemap；linkedhashmap；

　　　　加锁：hashtable；Collection.sychronizedXXX(传一个不加锁map，返回一个加了锁的map)，在并发性不是特别高的情况下可以使用上面两种；如果并发性比较高，用concurrenthashmap，如果还需要排序，就用concurrentskiplistmap；

附：Collection.sychronizedXXX用法：

1 public class T_SynchronizedList {
2     public static void main(String[] args){
3         List strs = new ArrayList<>();
4         List strsSync = Collections.synchronizedList(strs);
5     }
6 }

 2.3 并发容器——CopyOnWrite 写时复制容器

多线程环境下，写时效率低，读时效率高，适合写少读多的环境；

比较容器效率 ：

 1 public class T_CopyOnWrite {
 2     public static void main(String[] args){
 3         List lists =
 4                 //new ArrayList<>();//这个会出并发问题
 5                 //new Vector<>();
 6                 new CopyOnWriteArrayList<>();
 7         Random r = new Random();
 8         Thread[] ths = new Thread[100];
 9         for(int i=0; i){
10             Runnable task = new Runnable() {
11                 @Override
12                 public void run() {
13                     for(int j=0;j<1000;j++)
14                         lists.add("a"+r.nextInt(10000));
15                 }
16             };
17             ths[i] = new Thread(task);
18         }
19         runAndComputeTime(ths);
20         System.out.println(lists.size());
21     }
22     static void runAndComputeTime(Thread[] ths){
23         long s1 = System.currentTimeMillis();
24         Arrays.asList(ths).forEach(o->o.start());
25         Arrays.asList(ths).forEach(o->{
26             try{
27                 o.join();
28             }catch(InterruptedException e){
29                 e.printStackTrace();
30             }
31         });
32         long s2 = System.currentTimeMillis();
33         System.out.println(s2-s1);
34     }
35 }

CopyOnWriteArrayList：4853 100000
Vector：114 100000
ArrayList：97 86864（有错）

2.4 并发容器——ConcurrentLinkedQueue

常用方法：

 1 public class T_ConcurrentLinkedQueue {
 2     public static void main(String[] args){
 3         Queue strs = new ConcurrentLinkedQueue<>();
 4         for(int i=0; i<10; i++){
 5             //类似于add，有boolean返回值
 6             strs.offer("a"+i);
 7         }
 8         System.out.println(strs);
 9         System.out.println(strs.size());
10         System.out.println(strs.poll());//取值并删除
11         System.out.println(strs.size());
12         System.out.println(strs.peek());//只取值不删
13         System.out.println(strs.size());
14     }
15 }

2.5 并发容器——BlockingQueue

在高并发的情况下可以使用两种队列：

ConcurrentLinkedQueue：加锁式

BlockingQueue：阻塞式

LinkedBlockingQueue：

 1 public class T_LinkedBlockingQueue {
 2     static BlockingQueue strs = new LinkedBlockingQueue<>();
 3     static Random r = new Random();
 4     public static void main(String[] args){
 5         //生产者线程
 6         new Thread(()->{
 7             for(int i=0; i<100; i++){
 8                 try{
 9                     strs.put("a"+i);//使用put，如果满了，就会等待
10                 }catch(InterruptedException e){
11                     e.printStackTrace();
12                 }
13             }
14         },"p1").start();
15         //5个消费者线程
16         for(int i=0; i<5; i++){
17             new Thread(()->{
18                 for(;;){
19                     try{
20                         System.out.println(Thread.currentThread().getName()+"task-"+strs.take());//take如果空了，就会等待
21                     }catch(InterruptedException e){
22                         e.printStackTrace();
23                     }
24                 }
25             },"c"+i).start();
26         }
27     }
28 }

ArrayBlockingQueue：

 1 public class T_ArrayBlockingQueue {
 2     //有界队列
 3     static BlockingQueue strs = new ArrayBlockingQueue<>(10);
 4     static Random r = new Random();
 5     public static void main(String[] args) throws Exception{
 6         for(int i=0; i<10; i++){
 7             strs.put("a"+i);
 8         }
 9         //strs.put("aaa");//满了就会等待，程序阻塞
10         //strs.add("aaa");//队列满了会报异常
11         strs.offer("aaa");//队列满了不会报异常，也加不进去
12         //strs.offer("aaa",1, TimeUnit.SECONDS);//隔一段时间之内加不进去就不往里面加了
13         System.out.println(strs);
14     }
15 }

DelayQueue：

 1 public class T_DelayQueue {
 2     //加入队列的元素只有等一定的时间之后才能被消费者拿走
 3     //默认按等待时间排序
 4     //DelayQueue 需要实现接口
 5     static BlockingQueue tasks = new DelayQueue<>();
 6     static Random r = new Random();
 7     static class MyTask implements Delayed{
 8         long runningTime;
 9         MyTask(long rt){
10             this.runningTime = rt;
11         }
12         public int compareTo(Delayed o){
13             if(this.getDelay(TimeUnit.MILLISECONDS)<o.getDelay(TimeUnit.MILLISECONDS))
14                 return -1;
15             else if(this.getDelay(TimeUnit.MILLISECONDS)>o.getDelay(TimeUnit.MILLISECONDS))
16                 return 1;
17             else
18                 return 0;
19         }
20 
21         @Override
22         public long getDelay(TimeUnit unit) {
23             return unit.convert(runningTime-System.currentTimeMillis(), TimeUnit.MILLISECONDS);
24         }
25 
26         public String toString(){
27             return ""+runningTime;
28         }
29     }
30 
31     public static void main(String[] agrs) throws InterruptedException{
32         long now = System.currentTimeMillis();
33         MyTask t1 = new MyTask(now+1000);
34         MyTask t2 = new MyTask(now+2000);
35         MyTask t3 = new MyTask(now+1500);
36         MyTask t4 = new MyTask(now+2500);
37         MyTask t5 = new MyTask(now+500);
38 
39         tasks.put(t1);
40         tasks.put(t2);
41         tasks.put(t3);
42         tasks.put(t4);
43         tasks.put(t5);
44 
45         System.out.println(tasks);
46 
47         for(int i=0; i<5; i++){
48             System.out.println(tasks.take());
49         }
50     }
51 }

[1558935218208, 1558935218708, 1558935219208, 1558935220208, 1558935219708]
1558935218208
1558935218708
1558935219208
1558935219708
1558935220208

可以用来做定时执行任务

TransferQueue：

 1 public class T_TransferQueue {
 2     public static void main(String[] agrs) throws InterruptedException{
 3         LinkedTransferQueue strs = new LinkedTransferQueue<>();
 4         new Thread(()->{
 5             try{
 6                 System.out.println(strs.take());
 7             }catch(InterruptedException e){
 8                 e.printStackTrace();
 9             }
10         }).start();
11         //先启动几个消费者线程，生产者生产出一个产品的时候不往队列里加，
12         //首先去找有没有消费者，有消费者直接给消费者消费，没有就阻塞
13         //用在更高并发的情况下
14         strs.transfer("aaa");
15     }
16 }

SynchronusQueue：

 1 public class SynchronusQueue {//没有容量的队列
 2     public static void main(String[] agrs) throws InterruptedException{
 3         //同步队列是一种特殊的transferQueue
 4         //
 5         BlockingQueue strs = new SynchronousQueue<>();
 6         new Thread(()->{
 7             try{
 8                 System.out.println(strs.take());
 9             }catch(InterruptedException e){
10                 e.printStackTrace();
11             }
12         }).start();
13 
14         //strs.put("aaa");//不报错，阻塞等待消费者消费
15         strs.add("aaa");//报错queue full
16         System.out.println(strs.size);
17     }
18 }

 

3. 线程池

3.1 Executor

　　执行器，这是一个接口，内部维护了一个方法execute负责执行一项任务，参数为Runnable，方法具体实现有我们执行，如下面的代码，既可以使用单纯的方法调用也可以新砌一个新的线程去执行Runnable的run方法；

 1 public class T_MyExecutor implements Executor {
 2     public static void main(String[] agrs){
 3         new T_MyExecutor().execute(()->System.out.println("hello executor"));
 4     }
 5 
 6     public void execute(Runnable commend){
 7         commend.run();
 8         //new Thread(commend).run();
 9     }
10 }

3.2 ExecutorService

 　　代表着启动一系列的线程为用户提供服务（本质上也是一个执行器），Java8官方文档就举了一个网络接受连接池的例子（代码如下）。

 1 class NetworkService implements Runnable {
 2    private final ServerSocket serverSocket;
 3    private final ExecutorService pool;
 4  
 5    public NetworkService(int port, int poolSize)
 6        throws IOException {
 7      serverSocket = new ServerSocket(port);
 8      pool = Executors.newFixedThreadPool(poolSize);
 9    }
10  
11    public void run() { // run the service
12      try {
13        for (;;) {
14          pool.execute(new Handler(serverSocket.accept()));
15        }
16      } catch (IOException ex) {
17        pool.shutdown();
18      }
19    }
20  }
21  
22  class Handler implements Runnable {
23    private final Socket socket;
24    Handler(Socket socket) { this.socket = socket; }
25    public void run() {
26      // read and service request on socket
27    }
28  }

　　在这里ExecutorService就代表着一个线程池对外提供接受网络请求的服务，同时它也是一系列线程池的接口，如，RorkJoinPool、ScheduledThreadPoolExecutor,、ThreadPoolExecutor等。同时，它可以提交Callable与Runnable的对象返回一个未来的执行结果对象Future。Callable是一个增强版的Runnable，它的call方法可以抛出异常可以有返回值，返回值放在Future对象中，我们可以使用Future对象的get方法来获得返回值。

　　除了以上方法来创建一个ExecutorService还可以使用Executors这个工具类来创建它，在这里我们可以把Executors理解为就像utils，collections的工具类，是操作Executor的一个工具类。

2.3 ThreadPool 线程池

　　

 1 public class T_ThreadPool {
 2     public static void main(String[] agrs) throws InterruptedException{
 3         //Executors有一些工厂方法，newFixedThreadPool创建一个个数为5的线程池
 4         //ExecutorService接口是可以往里面扔任务（execute，submit）的，
 5         ExecutorService service = Executors.newFixedThreadPool(5);
 6         for(int i=0; i<6;i++){
 7             //5个线程，6个任务
 8             service.execute(()->{
 9                 try{
10                     TimeUnit.MILLISECONDS.sleep(500);
11                 }catch(InterruptedException e){
12                     e.printStackTrace();
13                 }
14                 System.out.println(Thread.currentThread().getName());
15             });
16         }
17         System.out.println(service);
18         //ExecutorService 常用方法
19         service.shutdown();//所有任务执行完关闭
20         System.out.println(service.isTerminated());//所有任务是否执行完了
21         System.out.println(service.isShutdown());//关了并一定是执行完了，代表正在关闭的过程中
22         System.out.println(service);
23     }
24 }

执行结果：

java.util.concurrent.ThreadPoolExecutor@7ba4f24f[Running, pool size = 5, active threads = 5, queued tasks = 1（排队的任务）, completed tasks = 0]
false
true
java.util.concurrent.ThreadPoolExecutor@7ba4f24f[Shutting down, pool size = 5, active threads = 5, queued tasks = 1, completed tasks = 0]
pool-1-thread-1
pool-1-thread-3
pool-1-thread-2
pool-1-thread-5
pool-1-thread-4
pool-1-thread-1

2.4 Future

 1 public class T_Future {
 2     public static void main(String[] agrs) throws InterruptedException, ExecutionException{
 3         //RunnableTask 不产生任何返回值
 4         //new了个Callable对象并把它包装成FutureTask
 5         FutureTask task = new FutureTask<>(()->{
 6             TimeUnit.MILLISECONDS.sleep(500);
 7             return 1000;
 8         });//相当于创建一个匿名类：new Callable（）{Integer call（）；}}
 9         //启动一个线程
10         new Thread(task).start();
11         System.out.println(task.get());//阻塞，任务执行完了返回值
12 
13         ExecutorService service = Executors.newFixedThreadPool(5);
14         Future f = service.submit(()->{
15             TimeUnit.MILLISECONDS.sleep(500);
16             return 1;
17         });
18         System.out.println(f.get());
19         System.out.println(f.isDone());//任务执行完没有啊
20         System.out.println(f.get());
21         System.out.println(f.isDone());
22     }
23 }

2.5 线程池——newFixedThreadPool

小程序：计算1-200000之间的质数

比较一个线程和多个线程的效率：

 1 public class T_ParallelComputing {
 2     public static void main(String[] agrs) throws InterruptedException, ExecutionException {
 3         long start = System.currentTimeMillis();
 4         //计算1-200000之间所有的质数
 5         List resulrs = getPrime(1,200000);
 6         //方法1：使用一个线程来计算
 7         long end = System.currentTimeMillis();
 8         System.out.println(end-start);
 9 
10         //方法2：使用线程池
11         final int cpuCoreNum = 4;
12         ExecutorService service = Executors.newFixedThreadPool(cpuCoreNum);
13         //创建4个任务，继承callable接口（有返回值）
14         MyTask t1 = new MyTask(1,80000);
15         MyTask t2 = new MyTask(80000,130000);
16         MyTask t3 = new MyTask(130000,170000);
17         MyTask t4 = new MyTask(170000,200000);
18         //将4个任务扔到线程池
19         Future> f1 = service.submit(t1);
20         Future> f2 = service.submit(t2);
21         Future> f3 = service.submit(t3);
22         Future> f4 = service.submit(t4);
23 
24         start = System.currentTimeMillis();
25         f1.get();
26         f2.get();
27         f3.get();
28         f4.get();
29         end = System.currentTimeMillis();
30         System.out.println(end-start);
31     }
32 
33     static class MyTask implements Callable> {
34         int startPos,endPos;
35 
36         MyTask(int s,int e){
37             this.startPos = s;
38             this.endPos = e;
39         }
40         public List call() throws Exception{
41             List r = getPrime(startPos, endPos);
42             return r;
43         }
44     }
45     static boolean isPrime(int num){
46         for(int i=2;i<=num/2;i++){
47             if(num%i==0) return false;
48         }
49         return true;
50     }
51     static List getPrime(int start,int end){
52         List results = new ArrayList<>();
53         for(int i=start;i<=end;i++){
54             if(isPrime(i)) results.add(i);
55         }
56         return results;
57     }
58 }

输出：

2513
786

2.6 线程池——CacheThreadPool

　　刚开始一个线程也没有，来一个任务起一个线程，如果来一个新的任务，线程池里刚好有一个线程空闲，直接让空闲线程执行任务，否则，起一个新线程；默认情况下，线程空闲超过60s自动销毁；

 1 public class T_CacheThreadPool {
 2     public static void main(String[] agrs) throws InterruptedException{
 3         ExecutorService service = Executors.newCachedThreadPool();
 4         System.out.println(service);
 5 
 6         for(int i=0;i<2;i++){
 7             service.execute(()->{
 8                 try{
 9                     TimeUnit.MILLISECONDS.sleep(500);
10                 }catch(InterruptedException e){
11                     e.printStackTrace();
12                 }
13                 System.out.println(Thread.currentThread().getName());
14             });
15         }
16         System.out.println(service);
17         TimeUnit.SECONDS.sleep(80);
18         System.out.println(service);
19     }
20 }

运行结果：

java.util.concurrent.ThreadPoolExecutor@1540e19d[Running, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 0]
java.util.concurrent.ThreadPoolExecutor@1540e19d[Running, pool size = 2, active threads = 2, queued tasks = 0, completed tasks = 0]
pool-1-thread-2
pool-1-thread-1
java.util.concurrent.ThreadPoolExecutor@1540e19d[Running, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 2]

2.7 线程池——SingleThreadPool

　　线程池里就一个线程，保证任务顺序执行

 1 public class SingleThreadPool {
 2     public static void main(String[] agrs){
 3         ExecutorService service = Executors.newSingleThreadExecutor();
 4         for(int i=0;i<5;i++){
 5             final int j = i;
 6             service.execute(()->{
 7                 System.out.println(j+" "+Thread.currentThread().getName());
 8             });
 9         }
10     }
11 }

输出：

0 pool-1-thread-1
1 pool-1-thread-1
2 pool-1-thread-1
3 pool-1-thread-1
4 pool-1-thread-1

2.8 线程池——SchedulePool

　　与DelayQueue相对应，执行定时的任务，线程池里的线程可以复用

 1 public class SchedulePool {
 2     public static void main(String[] agrs){
 3         ScheduledExecutorService service = Executors.newScheduledThreadPool(4);
 4         service.scheduleAtFixedRate(()->{
 5             try{
 6                 TimeUnit.MILLISECONDS.sleep(new Random().nextInt(1000));
 7             }catch(InterruptedException e){
 8                 e.printStackTrace();
 9             }
10             System.out.println(Thread.currentThread().getName());
11         },0,500, TimeUnit.MILLISECONDS);
12     }
13 }

 

2.9 线程池——WorkStealingPool

　　工作窃取：有一堆任务和一堆线程，每个线程都维护一个自己的任务队列，当一个线程执行完自己队列里的任务，会去别的线程队列中“偷”未执行的任务继续执行；

 1 public class WorkStealPool {
 2     public static void main(String[] agrs) throws IOException {
 3         ExecutorService service = Executors.newWorkStealingPool();
 4         //打印cup多少核
 5         System.out.println(Runtime.getRuntime().availableProcessors());
 6 
 7         service.execute(new R(1000));
 8         service.execute(new R(2000));
 9         service.execute(new R(2000));
10         service.execute(new R(2000));
11         service.execute(new R(2000));
12         //由于产生的是守护线程，主线程不阻塞看不到输出
13         System.in.read();
14     }
15     public static class R implements Runnable{
16         int time;
17         R(int t){
18             this.time = t;
19         }
20         public void run(){
21             try{
22                 TimeUnit.MILLISECONDS.sleep(time);
23             }catch (InterruptedException e){
24                 e.printStackTrace();
25             }
26             System.out.println(time+" "+Thread.currentThread().getName());
27         }
28     }
29 }

2.10 线程池——ForkJoinPool

　　如果有一项特别难以完成的大任务，可以把大任务切分成小的任务（Fork），最后合并小任务（Join）；

 1 public class ForkJoinPool2 {
 2     static int[] nums = new int[1000000];
 3     static final int MAX_NUM = 50000;
 4     static Random r = new Random();
 5     //求和
 6     static {
 7         for(int i=0; i){
 8             nums[i]=r.nextInt(100);
 9         }
10         System.out.println(Arrays.stream(nums).sum());
11     }
12 
13     static class AddTask extends RecursiveAction{
14         int start,end;
15         AddTask(int s, int e){
16             start = s;
17             end = e;
18         }
19         protected void compute(){
20             if(end-start<=MAX_NUM){
21                 long sum = 0L;
22                 for(int i=start;i){
23                     sum+=nums[i];
24                 }
25                 System.out.println("from:"+start+"to:"+end+"="+sum);
26             }else{
27                 int middle = start+(end-start)/2;
28                 AddTask subTask1 = new AddTask(start,middle);
29                 AddTask subTask2 = new AddTask(middle,end);
30                 subTask1.fork();
31                 subTask2.fork();
32             }
33         }
34     }
35     public static void main(String[] agrs) throws IOException{
36         ForkJoinPool fjp = new ForkJoinPool();
37         AddTask task = new AddTask(0,nums.length);
38 
39         fjp.execute(task);
40         System.in.read();
41     }
42 }

 

49508417
from:593750to:625000=1543717
from:468750to:500000=1548821
from:843750to:875000=1548865
from:968750to:1000000=1543900
from:718750to:750000=1539386
from:437500to:468750=1547593
from:812500to:843750=1538471
from:687500to:718750=1540626
from:562500to:593750=1545775
from:937500to:968750=1546144
from:406250to:437500=1550529
from:781250to:812500=1540313
from:218750to:250000=1556540
from:656250to:687500=1547825
from:93750to:125000=1545292
from:156250to:187500=1546528
from:531250to:562500=1544129
from:750000to:781250=1541918
from:500000to:531250=1551838
from:906250to:937500=1549404
from:625000to:656250=1550692
from:375000to:406250=1544616
from:62500to:93750=1554626
from:875000to:906250=1548556
from:343750to:375000=1554709
from:281250to:312500=1545881
from:125000to:156250=1550330
from:312500to:343750=1548005
from:250000to:281250=1552814
from:31250to:62500=1547229
from:187500to:218750=1545491
from:0to:31250=1547854

没有计算总的sun，因为RecursiveAction是没有返回值的，改为继承RecursiveTask，如下

 1 public class ForkJoinPool2 {
 2     static int[] nums = new int[1000000];
 3     static final int MAX_NUM = 50000;
 4     static Random r = new Random();
 5     //求和
 6     static {
 7         for(int i=0; i){
 8             nums[i]=r.nextInt(100);
 9         }
10         System.out.println(Arrays.stream(nums).sum());
11     }
12     static class AddTask extends RecursiveTask {
13         int start,end;
14         AddTask(int s, int e){
15             start = s;
16             end = e;
17         }
18         protected Long compute(){
19             if(end-start<=MAX_NUM){
20                 long sum = 0L;
21                 for(int i=start;i){
22                     sum+=nums[i];
23                 }
24                 return sum;
25             }
26             int middle = start+(end-start)/2;
27             AddTask subTask1 = new AddTask(start,middle);
28             AddTask subTask2 = new AddTask(middle,end);
29             subTask1.fork();
30             subTask2.fork();
31             return subTask1.join()+subTask2.join();
32         }
33     }
34     public static void main(String[] agrs) throws IOException{
35         ForkJoinPool fjp = new ForkJoinPool();
36         AddTask task = new AddTask(0,nums.length);
37         fjp.execute(task);
38         long result = task.join();
39         System.out.println(result);
40         //System.in.read();
41     }
42 }

2.11 线程池——ThreadPoolExecutor

　　线程池的底层实现：

发现它们都基于ThreadPoolExector，WorkStealingPool与ForkJoinPool的底层都是ForkJoinPool。

2530
570

2.12——parallelStreamAPI

 1 public class T_ParallelStreamAPI {
 2     public static void main(String[] agrs){
 3         List nums = new ArrayList<>();
 4         Random r = new Random();
 5         for(int i=0;i<10000;i++){
 6             nums.add(1000000+r.nextInt(1000000));
 7         }
 8         long start = System.currentTimeMillis();
 9         nums.forEach(v->isPrime(v));
10         long end = System.currentTimeMillis();
11         System.out.println(end-start);
12 
13         //使用parallelStream api
14         start = System.currentTimeMillis();
15         //默认使用多线程
16         nums.parallelStream().forEach(T_ParallelStreamAPI::isPrime);
17         end = System.currentTimeMillis();
18         System.out.println(end-start);
19     }
20     static boolean isPrime(int num){
21         for(int i=2;i){
22             if(num%i==0)
23                 return false;
24         }
25         return true;
26     }
27 }

2530
570