Java并发编程实战学习（一）

任务执行

任务：大多数服务器应用以用户的请求作为任务边界。
串行化任务：所有任务依次执行，受到网络，IO，DB等的影响，任务阻塞耗时长，导致程序响应慢，吞吐量低。只有在任务少，少量用户量的情况下才适用。
并行
每个任务创建一个线程是不合理的。
1.线程数量的上限有限制的,超出会影响系统稳定OOM异常：

32位系统地址空间大约是3g,，预留空间136M，xss0.5M，数量1万左右,另外linux文件里面也规定了线程最大数。
2.线程的生命周期的维护需要代价，创建销毁延迟运行，耗费计算资源。
3.大量的线程会造成大量内存占用，cg回收压力增加。

线程池

Executor将线程的创建与提交分开，耦合度变低，方便部署阶段调整。会引发OOM，建议自定义线程池使用。
1）newCachedThreadPool创建一个可缓存线程池，最大线程数是Max。
2）newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数。LinkedBlockingQueue是Max。
3）newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务。LinkedBlockingQueue是Max。
4）newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。LinkedBlockingQueue是Max。
Timer延迟任务问题：固定时间执行，异常不可恢复。
寻找合适的并发
大量相互独立且同构的任务需要并发处理

//多个futureList不要在循环里直接获取get()，需要全部任务submit后再获取，按顺序获取
        List> futures=new ArrayList<>();
        for (ImageInfo imageinfo:scanForImageInfo(source)){
            Callable task=new Callable() {
                @Override
                public ImageData call() throws Exception {
                    ImageData imagedata = imageinfo.downloadIamge();
                    return imagedata;
                }
            };
            Future imagefuture= executor.submit(task);
            futures.add(imagefuture);
        }

//渲染每个图片之间并行 利用CompletionService 先完成的先获取
 List info=scanForImageInfo(source);
        CompletionService completionService=new ExecutorCompletionService(executor);
        for (ImageInfo imageInfo:scanForImageInfo(source)) {
            completionService.submit(new Callable() {
                @Override
                public ImageData call() throws Exception {
                    ImageData imageData = imageInfo.downloadIamge();
                    return imageData;
                }
            });
        }
        executor.shutdown();
        for (int i = 0; i < info.size(); i++) {
                Future f=completionService.take();
                ImageData imageData = f.get();
                System.out.println("标签为："+imageData.getImageLabelId()+",图片二进制为："+imageData.getImageText());
         }

线程数量的选择
CPU周期
W:等待时间 C:计算时间 :CPU利用率

1.单个CPU拥有的总时间 W+C
2.单位线程需要的计算时间C
3.单个CPU能提供的线程为(W+C)/C=1+W/C
内存，数据库等资源的约束

饱和策略：优先队列与抛弃最旧的不能一同使用。通过Semaphore可以模拟饱和。

Semaphore semaphore=new Semaphore(5);
semaphore.acquire();
executorService.execute(new Runnable() {
     @Override
      public void run() {
         try { 
            //doing....
         }finally{
           semaphore.release();
         }
      }
});

线程工厂：实现ThreadFactory接口后自定义对线程的监控与异常。

任务的取消

标志位，阻塞队列可能有问题。

private volatile boolean cancelled;
public voic cancel(){cancelled=true;}
while (!cancelled){
          queue.put(p=p.nextprobablePrime);
      }

while (!Thread.currentThread().isInterrupted()){
          queue.put(p=p.nextprobablePrime);
      }

Future.cancel()
Executor.shutdown()
java是非抢占式(设置状态)。除非拥有某个线程，否则不能对它进行操作。服务（比如线程池）应该提供生命周期方法（shutdown），来关闭它的线程。