在多重程序系统中，大部分韶光用来做打算、逻辑判断等CPU动作的程序称之 CPU bound。例如一个打算圆周率至小数点一千位以下的程序，在实行的过程当中绝大部分韶光在用三角函数和开根号的打算，便是属于CPU bound的程序。
CPU bound的程序一样平常而言CPU占用率相称高。这可能是由于任务本身不太须要访问I/O设备，也可能是由于程序是多线程实现因此屏蔽了等待I/O的韶光。
线程数一样平常设置为：线程数 = CPU核数 + 1（当代CPU支持超线程）
IO密集型（I/O bound）（图片来自网络侵删）I/O密集型指的是系统的CPU性能相对硬盘、内存要好很多，此时，系统运作，大部分的状况是 CPU 在等 I/O（硬盘/内存）的读/写操作，此时 CPU Loading 并不高。
I/O bound的程序一样平常在达到性能极限时，CPU占用率仍旧较低。这可能是由于任务本身须要大量I/O操作，而 pipeline 做的不是很好，没有充分利用处理器能力。
线程数一样平常设置为：线程数 = ((线程等待韶光 + 线程CPU韶光) / 线程CPU韶光) CPU数目
CPU密集型 VS I/O密集型我们可以把任务分为打算密集型和I/O密集型。
打算密集型任务的特点是要进行大量的打算，花费CPU资源，比如打算圆周率、对视频进行高清解码等等，全靠CPU的运算能力。这种打算密集型任务虽然也可以用多任务完成，但是任务越多，花在任务切换的韶光就越多，CPU实行任务的效率就越低，以是，要最高效地利用CPU，打算密集型任务同时进行的数量应该即是CPU的核心数。
打算密集型任务由于紧张花费CPU资源，因此，代码运行效率至关主要。Python这样的脚本措辞运行效率很低，完备不适宜打算密集型任务。对付打算密集型任务，最好用C措辞编写。
第二种任务的类型是I/O密集型，涉及到网络、磁盘I/O的任务都是I/O密集型任务，这类任务的特点是CPU花费很少，任务的大部分韶光都在等待I/O操作完成（由于I/O的速率远远低于CPU和内存的速率）。对付I/O密集型任务，任务越多，CPU效率越高，但也有一个限度。常见的大部分任务都是I/O密集型任务，比如Web运用。
I/O密集型任务实行期间，99%的韶光都花在I/O上，花在CPU上的韶光很少，因此，用运行速率极快的C措辞更换用Python这样运行速率极低的脚本措辞，完备无法提升运行效率。对付I/O密集型任务，最得当的措辞便是开拓效率最高（代码量最少）的措辞，脚本措辞是首选，C措辞最差。
什么是 Fork/Join 框架？Fork/Join 框架是 Java7 供应了的一个用于并行实行的任务的框架，是一个把大任务分割成多少个小任务，终极汇总每个小任务结果后得到大任务结果的框架。
Fork 便是把一个大任务切分为多少个子任务并行的实行，Join 便是合并这些子任务的实行结果，末了得到这个大任务的结果。比如打算 1+2+......+10000，可以分割成10个子任务，每个子任务对1000个数进行求和，终极汇总这10个子任务的结果。如下图所示：
Fork/Join的特性：
ForkJoinPool 不是为了替代 ExecutorService，而是它的补充，在某些运用处景下性能比 ExecutorService 更好。（见 Java Tip: When to use ForkJoinPool vs ExecutorService ）ForkJoinPool 紧张用于实现“分而治之”的算法，特殊是分治之后递归调用的函数，例如 quick sort 等；ForkJoinPool 最适宜的是打算密集型的任务，如果存在 I/O、线程间同步、sleep() 等会造成线程永劫光壅塞的情形时，最好合营 MangedBlocker。关于“分而治之”的算法，可以查看《分治、回溯的实现和特性》
事情盗取算法事情盗取（work-stealing）算法 是指某个线程从其他行列步队里盗取任务来实行。
我们须要做一个比较大的任务，我们可以把这个任务分割为多少互不依赖的子任务，为了减少线程间的竞争，于是把这些子任务分别放到不同的行列步队里，并为每个行列步队创建一个单独的线程来实行行列步队里的任务，线程和行列步队逐一对应，比如A线程卖力处理A行列步队里的任务。
但是有的线程会先把自己行列步队里的任务干完，而其他线程对应的行列步队里还有任务等待处理。干完活的线程与其等着，不如去帮其他线程干活，于是它就去其他线程的行列步队里盗取一个任务来实行。而在这时它们会访问同一个行列步队，所以为了减少盗取任务线程和被盗取任务线程之间的竞争，常日会利用双端行列步队，被盗取任务线程永久从双端行列步队的头部拿任务实行，而盗取任务的线程永久从双端行列步队的尾部拿任务实行。
事情盗取算法的优点是充分利用线程进行并行打算，并减少了线程间的竞争，其缺陷是在某些情形下还是存在竞争，比如双端行列步队里只有一个任务时。并且花费了更多的系统资源，比如创建多个线程和多个双端行列步队。
ForkJoinPool 的每个事情线程都掩护着一个事情行列步队（WorkQueue），这是一个双端行列步队（Deque），里面存放的工具是任务（ForkJoinTask）。每个事情线程在运行中产生新的任务（常日是由于调用了 fork()）时，会放入事情行列步队的队尾，并且事情线程在处理自己的事情行列步队时，利用的是 LIFO 办法，也便是说每次从队尾取出任务来实行。每个事情线程在处理自己的事情行列步队同时，会考试测验盗取一个任务（或是来自于刚刚提交到 pool 的任务，或是来自于其他事情线程的事情行列步队），盗取的任务位于其他线程的事情行列步队的队首，也便是说事情线程在盗取其他事情线程的任务时，利用的是 FIFO 办法。在碰着 join() 时，如果须要 join 的任务尚未完成，则会先处理其他任务，并等待其完成。在既没有自己的任务，也没有可以盗取的任务时，进入休眠。Fork/Join的利用
利用场景示例
定义fork/join任务，如下示例，随机天生2000w条数据在数组当中，然后求和_
packagecom.niuh.forkjoin.recursivetask;importjava.util.concurrent.RecursiveTask;/RecursiveTask并行打算，同步有返回值ForkJoin框架处理的任务基本都能利用递归处理，比如求斐波那契数列等，但递归算法的毛病是：一只会只用单线程处理，二是递归次数过多时会导致堆栈溢出；ForkJoin办理了这两个问题，利用多线程并发处理，充分利用打算资源来提高效率，同时避免堆栈溢出发生。当然像求斐波那契数列这种小问题直策应用线性算法搞定可能更大略，实际运用中完备没必要利用ForkJoin框架，以是ForkJoin是核弹，是用来对付大家伙的，比如超大数组排序。最佳运用处景：多核、多内存、可以分割打算再合并的打算密集型任务/classLongSumextendsRecursiveTask<Long>{//任务拆分的最小阀值staticfinalintSEQUENTIAL_THRESHOLD=1000;staticfinallongNPS=(1000L10001000);staticfinalbooleanextraWork=true;//changetoaddmorethanjustasumintlow;inthigh;int[]array;LongSum(int[]arr,intlo,inthi){array=arr;low=lo;high=hi;}/fork()方法：将任务放入行列步队并安排异步实行，一个任务该当只调用一次fork()函数，除非已经实行完毕并重新初始化。tryUnfork()方法：考试测验把任务从行列步队中拿出单独处理，但不一定成功。join()方法：等待打算完成并返回打算结果。isCompletedAbnormally()方法：用于判断任务打算是否发生非常。/protectedLongcompute(){if(high-low<=SEQUENTIAL_THRESHOLD){longsum=0;for(inti=low;i<high;++i){sum+=array[i];}returnsum;}else{intmid=low+(high-low)/2;LongSumleft=newLongSum(array,low,mid);LongSumright=newLongSum(array,mid,high);left.fork();right.fork();longrightAns=right.join();longleftAns=left.join();returnleftAns+rightAns;}}}实行fork/join任务
packagecom.niuh.forkjoin.recursivetask;importcom.niuh.forkjoin.utils.Utils;importjava.util.concurrent.ForkJoinPool;importjava.util.concurrent.ForkJoinTask;publicclassLongSumMain{//获取逻辑处理器数量staticfinalintNCPU=Runtime.getRuntime().availableProcessors();/fortimeconversion/staticfinallongNPS=(1000L10001000);staticlongcalcSum;staticfinalbooleanreportSteals=true;publicstaticvoidmain(String[]args)throwsException{int[]array=Utils.buildRandomIntArray(2000000);System.out.println("cpu-num:"+NCPU);//单线程下打算数组数据总和longstart=System.currentTimeMillis();calcSum=seqSum(array);System.out.println("seqsum="+calcSum);System.out.println("singglethreadsort:->"+(System.currentTimeMillis()-start));start=System.currentTimeMillis();//采取fork/join办法将数组求和任务进行拆分实行，末了合并结果LongSumls=newLongSum(array,0,array.length);ForkJoinPoolfjp=newForkJoinPool(NCPU);//利用的线程数ForkJoinTask<Long>task=fjp.submit(ls);System.out.println("forkjoinsum="+task.get());System.out.println("singglethreadsort:->"+(System.currentTimeMillis()-start));if(task.isCompletedAbnormally()){System.out.println(task.getException());}fjp.shutdown();}staticlongseqSum(int[]array){longsum=0;for(inti=0;i<array.length;++i){sum+=array[i];}returnsum;}}Fork/Join框架事理Fork/Join 实在便是指由ForkJoinPool作为线程池、ForkJoinTask(常日实现其三个抽象子类)为任务、ForkJoinWorkerThread作为实行任务的详细线程实体这三者构成的任务调度机制。
ForkJoinWorkerThread
ForkJoinWorkerThread 直接继续了Thread，但是仅仅是为了增加一些额外的功能，并没有对线程的调度实行做任何变动。
ForkJoinWorkerThread 是被ForkJoinPool管理的事情线程，在创建出来之后都被设置成为了守护线程，由它来实行ForkJoinTasks。该类紧张为了掩护创建线程实例时通过ForkJoinPool为其创建的任务行列步队，与其他两个线程池全体线程池只有一个任务行列步队不同，ForkJoinPool管理的所有事情线程都拥有自己的事情行列步队，为了实现任务盗取机制，该行列步队被设计成一个双端行列步队，而ForkJoinWorkerThread的紧张任务便是实行自己的这个双端任务行列步队中的任务，其次是盗取其他线程的事情行列步队，以下是其代码片段：
publicclassForkJoinWorkerThreadextendsThread{//这个线程事情的ForkJoinPool池finalForkJoinPoolpool;//这个线程拥有的事情盗取机制的事情行列步队finalForkJoinPool.WorkQueueworkQueue;//创建在给定ForkJoinPool池中实行的ForkJoinWorkerThread。protectedForkJoinWorkerThread(ForkJoinPoolpool){//UseaplaceholderuntilausefulnamecanbesetinregisterWorkersuper("aForkJoinWorkerThread");this.pool=pool;//向ForkJoinPool实行池注册当前事情线程，ForkJoinPool为其分配一个事情行列步队this.workQueue=pool.registerWorker(this);}//该事情线程的实行内容便是实行事情行列步队中的任务publicvoidrun(){if(workQueue.array==null){//onlyrunonceThrowableexception=null;try{onStart();pool.runWorker(workQueue);//实行事情行列步队中的任务}catch(Throwableex){exception=ex;//记录非常}finally{try{onTermination(exception);}catch(Throwableex){if(exception==null)exception=ex;}finally{pool.deregisterWorker(this,exception);//撤销事情}}}}.....}ForkJoinTaskForkJoinTask ：与FutureTask一样， ForkJoinTask也是Future的子类，不过它是一个抽象类。
ForkJoinTask ：我们要利用 ForkJoin 框架，必须首先创建一个 ForkJoin 任务。它供应在任务中实行 fork() 和 join() 操作的机制，常日情形下我们不须要直接继续 ForkJoinTask 类，而只须要继续它的子类，Fork/Join框架供应类以下几个子类：
RecursiveAction：用于没有返回结果的任务。（比如写数据到磁盘，然后就退出。一个 RecursiveAvtion 可以把直接的事情分割成更小的几块，这样它们可以由独立的线程或者 CPU 实行。我们可以通过继续来实现一个 RecusiveAction）RescursiveTask：用于有返回结果的任务。（可以将自己的事情分割为多少更小任务，并将这些子任务的实行合并到一个集体结果。可以有几个水平的分割和合并）CountedCompleter ：在任务完成实行后会触发实行一个自定义的钩子函数。常量先容ForkJoinTask 有一个int类型的status字段：
其高16位存储任务实行状态例如NORMAL、CANCELLED或EXCEPTIONAL低16位预留用于用户自定义的标记。任务未完成之前status大于即是0，完成之后便是NORMAL、CANCELLED或EXCEPTIONAL这几个小于0的值，这几个值也是按大小顺序的：0（初始状态） > NORMAL > CANCELLED > EXCEPTIONAL.
publicabstractclassForkJoinTask<V>implementsFuture<V>,Serializable{/该任务的实行状态/volatileintstatus;//accesseddirectlybypoolandworkersstaticfinalintDONE_MASK=0xf0000000;//maskoutnon-completionbitsstaticfinalintNORMAL=0xf0000000;//mustbenegativestaticfinalintCANCELLED=0xc0000000;//mustbe<NORMALstaticfinalintEXCEPTIONAL=0x80000000;//mustbe<CANCELLEDstaticfinalintSIGNAL=0x00010000;//mustbe>=1<<16staticfinalintSMASK=0x0000ffff;//shortbitsfortags//非常哈希表//被任务抛出的非常数组，为了报告给调用者。由于非常很少见，以是我们不直接将它们保存在task工具中，而是利用弱引用数组。把稳，取消非常不会涌如今数组，而是记录在statue字段中//把稳这些都是static类属性，所有的ForkJoinTask共用的。privatestaticfinalExceptionNode[]exceptionTable;//非常哈希链表数组privatestaticfinalReentrantLockexceptionTableLock;privatestaticfinalReferenceQueue<Object>exceptionTableRefQueue;//在ForkJoinTask被GC回收之后，相应的非常节点工具的引用行列步队/固定容量的exceptionTable./privatestaticfinalintEXCEPTION_MAP_CAPACITY=32;//非常数组的键值对节点。//该哈希链表数组利用线程id进行比较，该数组具有固定的容量，由于它只掩护任务非常足够长，以便参与者访问它们，以是在持续的韶光内不应该变得非常大。但是，由于我们不知道末了一个joiner何时完成，我们必须利用弱引用并删除它们。我们对每个操作都这样做(因此完备锁定)。此外，任何ForkJoinPool池中的一些线程在其池变为isQuiescent时都会调用helpExpungeStaleExceptionsstaticfinalclassExceptionNodeextendsWeakReference<ForkJoinTask<?>>{finalThrowableex;ExceptionNodenext;finallongthrower;//抛出非常的线程idfinalinthashCode;//在弱引用消逝之前存储hashCodeExceptionNode(ForkJoinTask<?>task,Throwableex,ExceptionNodenext){super(task,exceptionTableRefQueue);//在ForkJoinTask被GC回收之后，会将该节点加入行列步队exceptionTableRefQueuethis.ex=ex;this.next=next;this.thrower=Thread.currentThread().getId();this.hashCode=System.identityHashCode(task);}}.................}除了status记录任务的实行状态之外，其他字段紧张是为了对任务实行的非常的处理，ForkJoinTask采取了哈希数组 + 链表的数据构造（JDK8以前的HashMap实现方法）存放所有（由于这些字段是static）的ForkJoinTask任务的实行非常。
fork 方法（安排任务异步实行）fork() 做的事情只有一件事，既是把任务推入当前事情线程的事情行列步队里（安排任务异步实行）。可以参看以下的源代码：
publicfinalForkJoinTask<V>fork(){Threadt;if((t=Thread.currentThread())instanceofForkJoinWorkerThread)((ForkJoinWorkerThread)t).workQueue.push(this);elseForkJoinPool.common.externalPush(this);returnthis;}该方法实在便是将任务通过push方法加入到当前事情线程的事情行列步队或者提交行列步队（外部非ForkJoinWorkerThread线程通过submit、execute方法提交的任务），等待被线程池调度实行，这是一个非壅塞的立即返回方法。
这里须要知道，ForkJoinPool线程池通过哈希数组+双端行列步队的办法将所有的事情线程拥有的任务行列步队和从外部提交的任务分别映射到哈希数组的不同槽位上。
join 方法（等待实行结果）join() 的事情则繁芜得多，也是 join() 可以使得线程免于被壅塞的缘故原由——不像同名的 Thread.join()。
检讨调用 join() 的线程是否是 ForkJoinThread 线程。如果不是（例如 main 线程），则壅塞当前哨程，等待任务完成。如果是，则不壅塞。查看任务的完成状态，如果已经完成，直接返回结果。如果任务尚未完成，但处于自己的事情行列步队内，则完成它。如果任务已经被其他的事情线程偷走，则盗取这个小偷的事情行列步队内的任务（以 FIFO 办法），实行，以期帮助它早日完成 join 的任务。如果偷走任务的小偷也已经把自己的任务全部做完，正在等待须要 join 的任务时，则找到小偷的小偷，帮助它完成它的任务。递归地实行第5步。将上述流程画成序列图的话便是这个样子：
由于文章篇幅有限，源码剖析请查看文章末端的“理解更多”
小结常日ForkJoinTask只适用于非循环依赖的纯函数的打算或伶仃工具的操作，否则，实行可能会碰着某种形式的去世锁，由于任务循环地等待彼此。但是，这个框架支持其他方法和技能(例如利用Phaser、helpQuiesce和complete)，这些方法和技能可用于布局办理这种依赖任务的ForkJoinTask子类，为了支持这些用法，可以利用setForkJoinTaskTag或compareAndSetForkJoinTaskTag原子性地标记一个short类型的值，并利用getForkJoinTaskTag进行检讨。ForkJoinTask实现没有将这些受保护的方法或标记用于任何目的，但是它们可以用于布局专门的子类，由此可以利用供应的方法来避免重新访问已经处理过的节点/任务。
ForkJoinTask该当实行相对较少的打算，并且该当避免不愿定的循环。大任务该当被分解成更小的子任务，常日通过递归分解。如果任务太大，那么并行性就不能提高吞吐量。如果太小，那么内存和内部任务掩护开销可能会超过处理开销。
ForkJoinTask是可序列化的，这使它们能够在诸如远程实行框架之类的扩展中利用。只在实行之前或之后序列化任务才是明智的，而不是在实行期间。
ForkJoinPoolForkJoinPool：ForkJoinTask 须要通过 ForkJoinPool 来实行，任务分割出的子任务会添加到当前事情线程所掩护的双端行列步队中，进入行列步队的头部。当一个事情线程的行列步队里暂时没有任务时，它会随机从其他事情线程的行列步队的尾部获取一个任务。
常量先容
ForkJoinPool 与 内部类 WorkQueue 共享的一些常量
//ConstantssharedacrossForkJoinPoolandWorkQueue//限定参数staticfinalintSMASK=0xffff;//低位掩码，也是最大索引位staticfinalintMAX_CAP=0x7fff;//事情线程最大容量staticfinalintEVENMASK=0xfffe;//偶数低位掩码staticfinalintSQMASK=0x007e;//workQueues数组最多64个槽位//ctl子域和WorkQueue.scanState的掩码和标志位staticfinalintSCANNING=1;//标记是否正在运行任务staticfinalintINACTIVE=1<<31;//失落活状态负数staticfinalintSS_SEQ=1<<16;//版本戳，防止ABA问题//ForkJoinPool.config和WorkQueue.config的配置信息标记staticfinalintMODE_MASK=0xffff<<16;//模式掩码staticfinalintLIFO_QUEUE=0;//LIFO行列步队staticfinalintFIFO_QUEUE=1<<16;//FIFO行列步队staticfinalintSHARED_QUEUE=1<<31;//共享模式行列步队，负数ForkJoinPool中的干系常量和实例字段:ForkJoinPool 中的干系常量和实例字段
//低位和高位掩码privatestaticfinallongSP_MASK=0xffffffffL;privatestaticfinallongUC_MASK=~SP_MASK;//生动线程数privatestaticfinalintAC_SHIFT=48;privatestaticfinallongAC_UNIT=0x0001L<<AC_SHIFT;//生动线程数增量privatestaticfinallongAC_MASK=0xffffL<<AC_SHIFT;//生动线程数掩码//事情线程数privatestaticfinalintTC_SHIFT=32;privatestaticfinallongTC_UNIT=0x0001L<<TC_SHIFT;//事情线程数增量privatestaticfinallongTC_MASK=0xffffL<<TC_SHIFT;//掩码privatestaticfinallongADD_WORKER=0x0001L<<(TC_SHIFT+15);//创建事情线程标志//池状态privatestaticfinalintRSLOCK=1;privatestaticfinalintRSIGNAL=1<<1;privatestaticfinalintSTARTED=1<<2;privatestaticfinalintSTOP=1<<29;privatestaticfinalintTERMINATED=1<<30;privatestaticfinalintSHUTDOWN=1<<31;//实例字段volatilelongctl;//主掌握参数volatileintrunState;//运行状态锁finalintconfig;//并行度|模式intindexSeed;//用于天生事情线程索引volatileWorkQueue[]workQueues;//主工具注册信息，workQueuefinalForkJoinWorkerThreadFactoryfactory;//线程工厂finalUncaughtExceptionHandlerueh;//每个事情线程的非常信息finalStringworkerNamePrefix;//用于创建事情线程的名称volatileAtomicLongstealCounter;//窃取任务总数，也可作为同步监视器/静态初始化字段///线程工厂publicstaticfinalForkJoinWorkerThreadFactorydefaultForkJoinWorkerThreadFactory;//启动或杀去世线程的方法调用者的权限privatestaticfinalRuntimePermissionmodifyThreadPermission;//公共静态poolstaticfinalForkJoinPoolcommon;//并行度，对应内部common池staticfinalintcommonParallelism;//备用线程数，在tryCompensate中利用privatestaticintcommonMaxSpares;//创建workerNamePrefix(事情线程名称前缀)时的序号privatestaticintpoolNumberSequence;//线程壅塞等待新的任务的超市价(以纳秒为单位)，默认2秒privatestaticfinallongIDLE_TIMEOUT=2000L1000L1000L;//2sec//空闲超时时间，防止timer未命中privatestaticfinallongTIMEOUT_SLOP=20L1000L1000L;//20ms//默认备用线程数privatestaticfinalintDEFAULT_COMMON_MAX_SPARES=256;//壅塞前自旋的次数，用在在awaitRunStateLock和awaitWork中privatestaticfinalintSPINS=0;//indexSeed的增量privatestaticfinalintSEED_INCREMENT=0x9e3779b9;ForkJoinPool 的内部状态都是通过一个64位的 long 型 变量ctl来存储，它由四个16位的子域组成:
AC: 正在运行事情线程数减去目标并行度，高16位TC: 总事情线程数减去目标并行度，中高16位SS: 栈顶等待线程的版本计数和状态，中低16位ID: 栈顶 WorkQueue 在池中的索引(poolIndex)，低16位ForkJoinPool.WorkQueue 中的干系属性:
//初始行列步队容量，2的幂staticfinalintINITIAL_QUEUE_CAPACITY=1<<13;//最大行列步队容量staticfinalintMAXIMUM_QUEUE_CAPACITY=1<<26;//64M//实例字段volatileintscanState;//Woker状态,<0:inactive;odd:scanningintstackPred;//记录前一个栈顶的ctlintnsteals;//窃取任务数inthint;//记录窃取者索引，初始为随机索引intconfig;//池索引和模式volatileintqlock;//1:locked,<0:terminate;else0volatileintbase;//下一个poll操作的索引(栈底/行列步队头)inttop;//一个push操作的索引(栈顶/行列步队尾)ForkJoinTask<?>[]array;//任务数组finalForkJoinPoolpool;//thecontainingpool(maybenull)finalForkJoinWorkerThreadowner;//当前事情行列步队的事情线程，共享模式下为nullvolatileThreadparker;//调用park壅塞期间为owner，其他情形为nullvolatileForkJoinTask<?>currentJoin;//记录被join过来的任务volatileForkJoinTask<?>currentSteal;//记录从其他事情行列步队窃取过来的任务内部数据构造ForkJoinPool采取了哈希数组 + 双端行列步队的办法存放任务，但这里的任务分为两类：
一类是通过execute、submit 提交的外部任务另一类是ForkJoinWorkerThread事情线程通过fork/join分解出来的事情任务ForkJoinPool并没有把这两种任务混在一个任务行列步队中，对付外部任务，会利用Thread内部的随机probe值映射到哈希数组的偶数槽位中的提交行列步队中，这种提交行列步队是一种数组实现的双端行列步队称之为Submission Queue，专门存放外部提交的任务。
对付ForkJoinWorkerThread事情线程，每一个事情线程都分配了一个事情行列步队，这也是一个双端行列步队，称之为Work Queue，这种行列步队都会被映射到哈希数组的奇数槽位，每一个事情线程fork/join分解的任务都会被添加到自己拥有的那个事情行列步队中。
在ForkJoinPool中的属性 WorkQueue[] workQueues 便是我们所说的哈希数组，其元素便是内部类WorkQueue实现的基于数组的双端行列步队。该哈希数组的长度为2的幂，并且支持扩容。如下便是该哈希数组的示意构造图：
如图，提交队列位于哈希数组workQueue的奇数索引槽位，事情线程的事情队列位于偶数槽位。
默认情形下，asyncMode为false时：因此事情线程把事情行列步队当着栈一样利用（后进先出），将分解的子任务推入事情行列步队的top端，取任务的时候也从top端取（凡是双端行列步队都会有两个分别指向行列步队两端的指针，这里便是图上画出的base和top）；而当某些事情线程的任务为空的时候，就会从其他行列步队（不限于workQueue，也会是提交行列步队）盗取（steal）任务，如图示拥有workQueue2的事情线程从workQueue1中盗取了一个任务，盗取任务的时候采取的是前辈先出FIFO的策略(即从base端盗取任务)，这样不但可以避免在取任务的时候与拥有其行列步队的事情线程发生冲突，从而减小竞争，还可以赞助其完成比较大的任务。asyncMode为true的话，拥有该事情行列步队的事情线程将按照前辈先出的策略从base端取任务，这一样平常只用于不须要返回结果的任务，或者事宜通报框架。ForkJoinPool布局函数其完全布局方法如下
privateForkJoinPool(intparallelism,ForkJoinWorkerThreadFactoryfactory,UncaughtExceptionHandlerhandler,intmode,StringworkerNamePrefix){this.workerNamePrefix=workerNamePrefix;this.factory=factory;this.ueh=handler;this.config=(parallelism&SMASK)|mode;longnp=(long)(-parallelism);//offsetctlcountsthis.ctl=((np<<AC_SHIFT)&AC_MASK)|((np<<TC_SHIFT)&TC_MASK);}主要参数阐明
parallelism：并行度（ the parallelism level），默认情形下跟我们机器的cpu个数保持同等，利用 Runtime.getRuntime().availableProcessors()可以得到我们机器运行时可用的CPU个数。factory：创建新线程的工厂（ the factory for creating new threads）。默认情形下利用ForkJoinWorkerThreadFactory defaultForkJoinWorkerThreadFactory。handler：线程非常情形下的处理器（Thread.UncaughtExceptionHandler handler），该处理器在线程实行任务时由于某些无法预见到的缺点而导致任务线程中断时进行一些处理，默认情形为null。asyncMode：这个参数要把稳，在ForkJoinPool中，每一个事情线程都有一个独立的任务行列步队asyncMode表示事情线程内的任务行列步队是采取何种办法进行调度，可以是前辈先出FIFO，也可以是后进先出LIFO。如果为true，则线程池中的事情线程则利用前辈先出办法进行任务调度，默认情形下是false。
ForkJoinPool.submit 方法
public<T>ForkJoinTask<T>submit(ForkJoinTask<T>task){if(task==null)thrownewNullPointerException();//提交到事情行列步队externalPush(task);returntask;}ForkJoinPool 自身拥有事情行列步队，这些事情行列步队的浸染是用来吸收由外部线程（非 ForkJoinThread 线程）提交过来的任务，而这些事情行列步队被称为 submitting queue 。 submit() 和 fork() 实在没有实质差异，只是提交工具变成了 submitting queue 而已（还有一些同步，初始化的操作）。submitting queue 和其他 work queue 一样，是事情线程”盗取“的工具，因此当个中的任务被一个事情线程成功盗取时，就意味着提交的任务真正开始进入实行阶段。
干系文章《并发编程之Executor线程池事理与源码解读》《并发编程之定时任务&定时线程池事理解析》《并发编程之Future&FutureTask深入解析》《并发编程之ThreadLocal深入理解》PS：以上代码提交在 Github ：
https://github.com/Niuh-Study/niuh-juc-final.git
文章持续更新，可以"大众号搜一搜「 一角钱技能 」第一韶光阅读， 本文 GitHub org_hejianhui/JavaStudy 已经收录，欢迎 Star。
