java多线程和并发

该包支持比常规Java Thread类更高级别的并发程序设计.

转帖一个ExecutorService类的，该类管理一个或者多个线程，你只要将任务(Runnable或者Callable实例)提交到(submit)执行器

让他们运行便可，然后会返回一个Futrue类得实例，该实例是对你的任务将返回的某些未知未来值（如果有）的引用。同时可以对创建线程的数量进行限制，如果有必要可以中断正在运行中的任务。

ExecutorService 建立多线程的步骤：

1。定义线程类 class Handler implements Runnable{ } 2。建立ExecutorService线程池 ExecutorService executorService = Executors.newCachedThreadPool(); 或者 int cpuNums = Runtime.getRuntime().availableProcessors(); //获取当前系统的CPU 数目 ExecutorService executorService =Executors.newFixedThreadPool(cpuNums * POOL_SIZE); //ExecutorService通常根据系统资源情况灵活定义线程池大小 3。调用线程池操作 循环操作，成为daemon,把新实例放入Executor池中 while(true){ executorService.execute(new Handler(socket));  // class Handler implements Runnable{ 或者 executorService.execute(createTask(i)); //private static Runnable createTask(final int taskID) } execute(Runnable对象)方法 其实就是对Runnable对象调用start()方法 （当然还有一些其他后台动作，比如队列，优先级，IDLE timeout，active激活等）

 

几种不同的ExecutorService线程池对象

1.newCachedThreadPool() -缓存型池子，先查看池中有没有以前建立的线程，如果有，就reuse.如果没有，就建一个新的线程加入池中 -缓存型池子通常用于执行一些生存期很短的异步型任务  因此在一些面向连接的daemon型SERVER中用得不多。 -能reuse的线程，必须是timeout IDLE内的池中线程，缺省timeout是60s ,超过这个IDLE时长，线程实例将被终止及移出池。 注意，放入CachedThreadPool的线程不必担心其结束，超过TIMEOUT不活动，其会自动被终止。 2. newFixedThreadPool -newFixedThreadPool与cacheThreadPool差不多，也是能reuse就用，但不能随时建新的线程 -其独特之处:任意时间点，最多只能有固定数目的活动线程存在，此时如果有新的线程要建立，只能放在另外的队列中等待 ，直到当前的线程中某个线程终止直接被移出池子 -和cacheThreadPool不同，FixedThreadPool没有IDLE机制（可能也有，但既然文档没提，肯定非常长，类似依赖上层的TCP或UDP IDLE机制之类的），所以FixedThreadPool多数针对一些很稳定很固定的正规并发线程，多用于服务器  -从方法的源代码看，cache池和fixed 池调用的是同一个底层池，只不过参数不同:  fixed池线程数固定，并且是0秒IDLE（无IDLE）  cache池线程数支持0-Integer.MAX_VALUE(显然完全没考虑主机的资源承受能力），60秒IDLE 3.ScheduledThreadPool -调度型线程池 -这个池子里的线程可以按schedule依次delay执行，或周期执行 4.SingleThreadExecutor -单例线程，任意时间池中只能有一个线程 -用的是和cache池和fixed池相同的底层池，但线程数目是1-1,0秒IDLE（无IDLE）

上面四种线程池，都使用Executor的缺省线程工厂建立线程，也可单独定义自己的线程工厂 
下面是缺省线程工厂代码:

也可自己定义ThreadFactory，加入建立池的参数中

static class DefaultThreadFactory implements ThreadFactory { static final AtomicInteger poolNumber = new AtomicInteger(1); final ThreadGroup group; final AtomicInteger threadNumber = new AtomicInteger(1); final String namePrefix; DefaultThreadFactory() { SecurityManager s = System.getSecurityManager(); group = (s != null)? s.getThreadGroup() :Thread.currentThread().getThreadGroup(); namePrefix = "pool-" + poolNumber.getAndIncrement() + "-thread-"; } public Thread newThread(Runnable r) { Thread t = new Thread(group, r,namePrefix + threadNumber.getAndIncrement(),0); if (t.isDaemon()) t.setDaemon(false); if (t.getPriority() != Thread.NORM_PRIORITY) t.setPriority(Thread.NORM_PRIORITY); return t; } }

Executor的execute()方法 
execute() 方法将Runnable实例加入pool中,并进行一些pool size计算和优先级处理
execute() 方法本身在Executor接口中定义,有多个实现类都定义了不同的execute()方法
如ThreadPoolExecutor类（cache,fiexed,single三种池子都是调用它）的execute方法如下：

public void execute(Runnable command) { if (command == null) throw new NullPointerException(); if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) { if (runState == RUNNING && workQueue.offer(command)) { if (runState != RUNNING || poolSize == 0) ensureQueuedTaskHandled(command); } else if (!addIfUnderMaximumPoolSize(command)) reject(command); // is shutdown or saturated } }

ThreadPoolExecutor几点使用建议

先看一副图，描述了ThreadPoolExecutor的工作机制: 

整个ThreadPoolExecutor的任务处理有4步操作：

 

• 第一步，初始的poolSize < corePoolSize，提交的runnable任务，会直接做为new一个Thread的参数，立马执行
• 第二步，当提交的任务数超过了corePoolSize，就进入了第二步操作。会将当前的runable提交到一个block queue中
  
• 第三步，如果block queue是个有界队列，当队列满了之后就进入了第三步。如果poolSize < maximumPoolsize时，会尝试new 一个Thread的进行救急处理，立马执行对应的runnable任务
• 第四步，如果第三步救急方案也无法处理了，就会走到第四步执行reject操作。

几点说明：(相信这些网上一搜一大把，我这里简单介绍下，为后面做一下铺垫)

• block queue有以下几种实现：
  1. ArrayBlockingQueue :  有界的数组队列
  2. LinkedBlockingQueue : 可支持有界/无界的队列，使用链表实现
  3. PriorityBlockingQueue : 优先队列，可以针对任务排序
  4. SynchronousQueue : 队列长度为1的队列，和Array有点区别就是：client thread提交到block queue会是一个阻塞过程，直到有一个worker thread连接上来poll task。
• RejectExecutionHandler是针对任务无法处理时的一些自保护处理：
  1. Reject 直接抛出Reject exception
  2. Discard 直接忽略该runnable，不可取
  3. DiscardOldest 丢弃最早入队列的的任务
  4. CallsRun 直接让原先的client thread做为worker线程，进行执行

容易被人忽略的点：

1.  pool threads启动后，以后的任务获取都会通过block queue中，获取堆积的runnable task.

所以建议：  block size >= corePoolSize ，不然线程池就没任何意义

2.  corePoolSize 和 maximumPoolSize的区别， 和大家正常理解的数据库连接池不太一样。

  *  据dbcp pool为例，会有minIdle , maxActive配置。minIdle代表是常驻内存中的threads数量，maxActive代表是工作的最大线程数。

  *  这里的corePoolSize就是连接池的maxActive的概念，它没有minIdle的概念(每个线程可以设置keepAliveTime，超过多少时间多有任务后销毁线程，默认只会针对maximumPoolSize参数的线程生效，可以设置allowCoreThreadTimeOut=true，就可以对corePoolSize进行idle回收)。 

  * 这里的maximumPoolSize，是一种救急措施的第一层。当threadPoolExecutor的工作threads存在满负荷，并且block queue队列也满了，这时代表接近崩溃边缘。这时允许临时起一批threads，用来处理runnable，处理完后通过keepAliveTime进行调度回收。

所以建议：   maximumPoolSize >= corePoolSize =期望的最大线程数。 (我曾经配置了corePoolSize=1, maximumPoolSize=20, blockqueue为无界队列，最后就成了单线程工作的pool。典型的配置错误)

3. 善用blockqueue和reject组合. 这里要重点推荐下CallsRun的Rejected Handler，从字面意思就是让调用者自己来运行。

我们经常会在线上使用一些线程池做异步处理，比如我前面做的 (业务层)异步并行加载技术分析和设计, 将原本串行的请求都变为了并行操作，但过多的并行会增加系统的负载(比如软中断，上下文切换)。所以肯定需要对线程池做一个size限制。但是为了引入异步操作后，避免因在block queue的等待时间过长，所以需要在队列满的时，执行一个callsRun的策略，并行的操作又转为一个串行处理，这样就可以保证尽量少的延迟影响。

所以建议：   RejectExecutionHandler = CallsRun ,  blockqueue size = 2 * poolSize (为啥是2倍poolSize，主要一个考虑就是瞬间高峰处理，允许一个thread等待一个runnable任务)