&＃160;

2013/06/13

这篇文章主如果翻译了一项目组jdk自带线程池的API。底本是不想翻译的，成果发明上周看完今后，过了个端午，玩了三天回来发明有些细节又忘怀了。。想来想去，决意还是翻译一遍，英语程度有限。。剩下的你懂的。。

我是这么规划的，从上层接口开端一层一层往下。开端工作：

先发一张这篇筹算翻译的接口及类的定义的层级关系

&＃160;

1.java.util.concurrent.utor

java.util.concurrent.utor，一个用于履行Runnable任务的实例接口。这个接口供给了一种将每个任务的提交与每个任务具体如何履行解耦的体式格式，这此中包含线程的应用与调剂的细节等等。一个utor凡是被用于调换哪些显示的创建线程的办法。举个栗子，与其说显示的调用new Thread（new RunnableTask（） ）.start（） 去履行一个堆任务，你还不如入像下面这么做：

utor executor = anutor;

 executor.execute（new RunnableTask1（））;

 executor.execute（new RunnableTask2（））;

 ...

上方这么写，每次履行execute办法就创建一个新线程，然则，utor接口并没有严格的请求任务的履行必须是异步的。举个简单的栗子，一个executor也能让一个提交上来的任务直接在调用executor.execute办法的线程上履行，例如：

class Directutor implements utor {

     public void execute（Runnable r） {

         r.run（）;

     }

 }

更广泛的写法是让任务履行在调用executor.execute办法的线程之外的线程上。下面的这个executor就为每一个任务创建一个新线程：

class ThreadPerTaskutor implements utor {

     public void execute（Runnable r） {

         new Thread（r）.start（）;

     }

 }

很多utor的实现类会附加一些限制类似于如何或者何时调用任务。下面的这个executor显现了一个复合型的executor，其将任务列队并移交给第二个executor履行：

class Serialutor implements utor {

     final Queue<Runnable> tasks = new ArrayDeque<Runnable>（）;

     final utor executor;

     Runnable active;



     Serialutor（utor executor） {

         this.executor = executor;

     }



     public synchronized void execute（final Runnable r） {

         tasks.offer（new Runnable（） {

             public void run（） {

                 try {

                     r.run（）;

                 } finally {

                     scheduleNext（）;

                 }

             }

         }）;

         if （active == null） {

             scheduleNext（）;

         }

     }



     protected synchronized void scheduleNext（） {

         if （（active = tasks.poll（）） != null） {

             executor.execute（active）;

         }

     }

 }

这个utor接口的实现为这个包下的utorService，其是一个加倍拓展的接口。ThreadPoolutor类供给了可扩大的线程池的实现。utors类为上方说的这些utors供给了便利的工厂办法。

内存一致性影响：一个调用了utor.execute办法的线程，此中除了调用utor.execute办法之外的操纵该当那优先于这个runnable对象的履行，这个履行可能处于此外线程中。

2.java.util.concurrent.utorService

utorService是一个utor，供给了用于封闭本身的办法，还有可以返回Future对象以追寻一个或多个任务的工作流程的办法。

一个utorService是可以被封闭的，如许会导致拒绝任的任务。utorService定义了两个不合的办法去封闭本身。一个是shutdown（）办法，这个办法容许在调用这个办法之前提交上来的任务履行完毕，随后封闭。别的一个shutdownNow（）办法例阻拦还在守候的任务启动并且试图去停止正在履行的任务。在utorService封闭的根蒂根基上，一个executor将没有可以履行的的任务，没有守候中的任务，没有新的提交上来的任务。一个不应用的utorService该当被封闭，从而容许收受接管它所占用的资料。

submit（）办法拓展了utor.execute办法，创建并返回了一个Future对象，这个对象可以被用于作废履行或者守候任务完成状况。办法invokeAny和invokeAll供给了最经常应用到的大项目组模板代码，如履行一系列的任务并且守候此中一个或者所有的任务完成（若是要重写上诉办法，推荐持续类 utorCompletionService 并重写自定义的上述办法）

utors类供给了utorService地点包下 utorService 类及子类的工厂办法。

应用示例：

这里是一个有一个线程池用于办事发送来的恳求的收集办事的简单设计，这里应用utors.newFixedThreadPool工厂办法来生成固定个数的线程池：

class NetworkService implements Runnable {

   private final ServerSocket serverSocket;

   private final utorService pool;



   public NetworkService（int port， int poolSize）

       throws IOException {

     serverSocket = new ServerSocket（port）;

     pool = utors.newFixedThreadPool（poolSize）;

   }



   public void run（） { // run the service

     try {

       for （;;） {

         pool.execute（new Handler（serverSocket.accept（）））;

       }

     } catch （IOException ex） {

       pool.shutdown（）;

     }

   }

 }



 class Handler implements Runnable {

   private final Socket socket;

   Handler（Socket socket） { this.socket = socket; }

   public void run（） {

     // read and service request on socket

   }

 }

下面的办法分两阶段封闭一个utorService，第一步，调用shutdow办法拒绝提交上来的任务；第二步，若是有须要，则调用shutdowNow办法，作废任何延迟的任务：

void shutdownAndAwaitTermination（utorService pool） {

   pool.shutdown（）; // Disable new tasks  being submitted

   try {

     // Wait a while for existing tasks to terminate

     if （!pool.awaitTermination（60， TimeUnit.SECONDS）） {

       pool.shutdownNow（）; // Cancel currently executing tasks

       // Wait a while for tasks to respond to being cancelled

       if （!pool.awaitTermination（60， TimeUnit.SECONDS））

           System.err.println（"Pool did not terminate"）;

     }

   } catch （InterruptedException ie） {

     // （Re-）Cancel if current thread also interrupted

     pool.shutdownNow（）;

     // Preserve interrupt status

     Thread.currentThread（）.interrupt（）;

   }

 }

内存一致性影响：一个线程中调用utorService.submit办法之外的任何操纵该当优先于这个被提交任务被履行，这些被提交任务的履行该当优先于经由过程Future.get（）返回成果。

3.java.util.concurrent.AbstractutorService

供给utorService的默认实现。这个类实现了submit，invokeAny和invokeAll办法，这些办法经由过程调用newTaskFor办法获得RunnableFuture对象，指向一个FutureTask引用。例如，submit（Runnable）办法就返回一个经由过程履行newTaskFor办法获得的RunnableFuture对象。子类可以重写newTaskFor办法，返回其他实现了RunnableFuture接口的实例。

扩大举例：

一下是一个自定义的ThreadPoolutor的概要设计，应用了CustomTask类型调换默认的FutureTask：

public class CustomThreadPoolutor extends ThreadPoolutor {



   static class CustomTask<V> implements RunnableFuture<V> {...}



   protected <V> RunnableFuture<V> newTaskFor（Callable<V> c） {

       return new CustomTask<V>（c）;

   }

   protected <V> RunnableFuture<V> newTaskFor（Runnable r， V v） {

       return new CustomTask<V>（r， v）;

   }

   // ... add constructors， etc.

 }

&＃160;

4.java.util.concurrent.ThreadPoolutor

ThreadPoolutor是一个utorService，它经由过程应用一个或者有若干个保存在池中的线程履行提交上来的任务，经由过程utors的工厂办法可以创建一般设备的ThreadPoolutor。

线程池旨在解决两个题目：1.线程池一般来说在处理惩罚多量异步任务时可以或许有更好的发挥解析，原因是它削减了每个任务均匀的履行开销。2.它供给了一种限制和经管资料的手段，此中包含它所经管的线程，以及它所经管的任务队列。每一个ThreadPoolutor都包含了根蒂根基的统计信息，例如这个线程池完成的任务数等等。

ThreadPoolutor供给了高可配的高低文景象，包含多量的可调剂的参数以及遍历的钩子办法，使得ThreadPoolutor能加倍通用。尽管如此，我们还是建议尽量应用utors中的便利工厂办法：utors.newCachedThreadPool（一个的线程池，共同主动线程收受接管），utors.newFixedThreadPool（固定大小的线程池），以及utors.newSingleThreadutor（自力线程线程池），这些预定义的线程池可以实用于大项目组的应用处景。若是这些不实用的话，可以应用下面的指南进行人工设备并返回你想要的ThreadPoolutor：

核心及最大池大小：

一个ThreadPoolutor会按照coolPoolSize和maximumPoolSize的设置主动的调剂线程池大小。当有一个新任务被提交（ThreadPoolutor.execute），且这一时刻少于corePoolSize数量的线程正在运行，那么一个新的线程将会被创建，并且用于处理惩罚这个新任务，即使当时存在其他余暇线程。若是这一时刻有跨越coolPoolSize数量然则少于maximumPoolSize数量的线程正在运行，仅当任务队列充斥的状况时才会创建新线程。经由过程设置corePoolSize和maximumPoolSize为同一个值，你可以创建一个固定大小的线程池。经由过程设置maximumPoolSize为一个本质上来说无穷的值，例如Integer.MAX_VALUE，你容许这个池容纳随便率性数量的并发线程。大项目组景象下，corePoolSize和maximumPoolSize都仅在机关办法中设定，然则你也可以经由过程ThreadPoolutor.setCorePoolSize和ThreadPoolutor.setMaximumPoolSize办法来动态设置。

按需机关办法：

默认的机关办法中，即使是核心线程也是在有新任务达到时进行初始化创建并启动，然则这件工作可以经由过程重写机关并调用ThreadPoolutor.restartCoreThead办法或者ThreadPoolutor.prestartAllCoreThreads办法从而在机关办法办法中启动核心线程。因为你可能想要启动一项目组线程，介于你的任务队列在初始化的时辰就不是空的。

创建新线程：

新的线程经由过程java.util.concurrent.ThreadFactory创建。若是没有希罕声明，一个utors.defaultThreadFactory对象将会被应用。这个对象创建出的线程都属于一个TrheadGroup，有着雷同的优先级，并且都长短守护过程。经由过程供给不合的ThreadFactory，你可以改变Thread的定名体式格式，所属的ThreadGroup，优先级以及是否是守护过程，等等。若是一个ThreadFactory调用newThread办法创建线程失败，返回一个null，调用ThreadFactory的utor依然持续运行，只是可能不克不及够处理惩罚任何任务。

存活时候：

若是一个线程池当前有跨越corePoolSize的线程数，额外的线程当其余暇时候跨越keepAliveTime就会被终止。如许就供给了当线程池并不是很活泼的时辰，可以尽量削减资料消费的手段。若是这个线程池之后又变得活泼起来，新的线程将会被创建并入池。keepAliveTime这个参数也可以同过ThreadPoolutor.setKeepAliveTime办法动态批改。经由过程应用Long.MAX_VALUE（TimeUnit.NANOSECONDS）可以或许有效的阻拦余暇线程被终止。默认景象下，终止余暇线程的策略只会被应用到超出corePoolSize数的线程上，当时调用ThreadPoolutor.allowCoreThreadTimeOut（boolean）办法可以使这一超时策略同样感化于核心线程上，前提是keepAliveTime的值非0.

任务队列：

随便率性的BlockingQueue队列都有可能被用于传输和存储提交的任务。这个队列的调用是和线程池的大小互相干注的：

若是少于corePoolSize数量的线程正在运行，那么utor老是选择添加一个新线程而不是将任务入队列。

若是多余corePoolSize数量的线程正在运行，那么utor老是选择将任务入队列而不是增长一个新线程。

若是任务队列已满，且线程池未满，则utor会选择创建新的线程。若任务队列和线程池都已饱和，则拒绝恳求。

下面有三个根蒂根基的列队策略:

1.直接交付。一个不错的默认选择是同部队列，这种队列直接交付任务给Thread而从不存储任务。如许，一个因为没有余暇线程而试图入队列的任务将会不克不及进入队列，取而代之的是创建一个新的线程来处理惩罚任务。这种策略避免了当多个任务之间存在彼此依附时产存亡锁的景象。直接交付策略一般来说请求你有一个的线程池从而包管不会拒绝新提交的任务。然则话说回来，当任务的达到均匀速度高于任务的均匀处理惩罚熟读时，这种策略也有可能存在无线的线程增长的弊病。

2.队列。经由过程应用队列（例如 LinkedBlockingQueue ，不设置预定义大小，这是它就是个队列） ，当所有核心线程都在工作时，新入队列的任务就讲守候。如许不会有跨越corePoolSize的线程被创建（如许maximumPoolSize这个值就理所当然的失效了）。这种策略可能斗劲合适于每一个任务都是完全自力的景象，这种景象下每一个任务的履行都不会影响另一个任务的履行 。举个栗子，一个网页办事器，应用队列策略就可以或许腻滑的处理惩罚短暂爆发的恳求岑岭。然则，也必须承认当任务的达到均匀速度高于任务的均匀处理惩罚速度时，将会呈现无穷任务队列络续增长的景象。

3.有界队列。一个有界的队列（例如一个ArrayBlockingQueue）经由过程设置maximumPoolSize可以帮助我们防止资料耗竭的景象，然则这种策略比前两种加倍难以和谐和把握。队列的大小和线程池的大小须要彼此调和：应用大的任务队列和小的线程池可以最小化CPU应用率，OS资料，以及景象变更开销，然则可能导致工钱的低吞吐量。若是任务频繁的梗阻（例如I/O梗阻），就该当腾出时候来进步你容许的高线程数。应用小的任务队列一般来说请求大的线程池，如许可以或许充沛哄骗CPU，然则也可能碰到不成预感的调剂开销，同样会降落吞吐量。

拒绝任务：

经由过程ThreadPoolutor.execute提交的新任务，当utor已经封闭，或者utor应用有界的工作队列和线程池且已经饱和，这个任务将会被拒绝。在上方说的随便率性一个景象中，utor的execute办法将会本身的RejectedutionHandler的rejectedution办法。4个预定义的处理惩罚策略如下所示：

1.默认的ThreadPoolutor.AbortPolicy:handler将会抛出一个运行时Rejectutionption。

2.ThreadPoolutor.CallerRunsPolicy:调用utor.execute的线程将会本身运行这个任务。这个策略供给一个简单的反馈把握机制从而降落新任务的提交速度。

3.ThreadPoolutor.DiscardPolicy:简单的扔掉不克不及履行的任务。

4.ThreadPoolutor.DiscardOldestPolicy:若是utor并没有封闭，而是因为饱和而拒绝任务，那么在任务队列头的任务将会被扔掉，然后从头测验测验履行当前任务（若是仍然失败，则反复这一策略）

可以定义并应用其他类型的RejectedutionHandler 类。这么做的话请求须要额外的警惕，希罕是这个策略被设计用于指定线程池大小或者任务队列大小的的线程池。

钩子办法：

ThreadPoolutor 供给了protected润饰的可重写的办法ThreadPoolutor.beforeute 和 ThreadPoolutor.afterute办法分别在履行任务前后调用。这两个办法可以被用于机关履行景象；例如，从头初始化ThreadLocal变量，收集统计信息，或者增长日记实体。值得一说的是，ThreadPoolutor.terminated办法也可以被重写用于在一个utor将要终止时，履行一些特此外，必须被完成的流程。

若是 钩子办法或者回调办法抛出异常，线程池内部的正在工作的线程会返回失败或者忽然终止。

队列保护：

办法ThreadPoolutor.getQueue 容许以把守和调试的目标接见工作队列。以其他任何目标调用此办法都是很是不倡导的。这里供给两个办法：ThreadPoolutor.remove和ThreadPoolutor.purge。当多量的守候任务被作废时可以应用这两个办法帮助内存收受接管。

终止办法：

一个线程池终极没有任何法度引用且池中没有任何线程的时辰，将会主动被封闭。若是你想要确认这些未被引用的线程池即使不手工调用ThreadPoolutor.shutdown也会被收受接管，你可以测验测验如许做：设置合适的keepAliveTime，设置核心线程数为0或者设置ThreadPoolutor.allowCoreThreadTimeOut（true），经由过程以上办法可以使线程池中的线程全部终极灭亡。

扩大栗子：

大多半ThreadPoolutor的子类都邑重写一个或者多个钩子办法。例如，这里是一个子类增长了一个简单的暂停/恢复 特点：

class PausableThreadPoolutor extends ThreadPoolutor {

   private boolean isPaused;

   private ReentrantLock pauseLock = new ReentrantLock（）;

   private Condition unpaused = pauseLock.newCondition（）;



   public PausableThreadPoolutor（...） { super（...）; }



   protected void beforeute（Thread t， Runnable r） {

     super.beforeute（t， r）;

     pauseLock.lock（）;

     try {

       while （isPaused） unpaused.await（）;

     } catch （InterruptedException ie） {

       t.interrupt（）;

     } finally {

       pauseLock.unlock（）;

     }

   }



   public void pause（） {

     pauseLock.lock（）;

     try {

       isPaused = true;

     } finally {

       pauseLock.unlock（）;

     }

   }



   public void resume（） {

     pauseLock.lock（）;

     try {

       isPaused = false;

       unpaused.signalAll（）;

     } finally {

       pauseLock.unlock（）;

     }

   }

 }

这个栗子中应用到了jdk1.5中的新的并发特点Lock，Condition用以调换Object的wait（）和notify（）办法。

终于翻译完了-&＃160; -