1.Java：Java中的源码Fork/Join框架的并行编程基础
2.java中Fork-Join框架原理及应用
3.java的fork/join任务,你写对了吗?
4.java源文件是什么源文件是什么
5.Java并发编程：Fork/Join框架解释
6.如何fork一个JAVA进程

Java：Java中的Fork/Join框架的并行编程基础

       并行编程，是源码多核 CPU 技术出现后，充分利用处理资源的源码重要方式。它允许程序中的源码多个进程并发执行，从而极大提升性能与效率。源码Java 并发 API 中的源码libgdx游戏源码 Fork/Join 框架，就是源码实现并行化算法的强大工具。本文将探索使用 Java 中的源码 Fork/Join 框架进行并行编程的概念。

       并行编程的源码核心在于，使用多个处理器完成任务，源码这与多线程有相似之处。源码然而，源码它们在实质上大不相同。源码多线程提供了一种错觉上的源码并行处理，实际上是源码通过时间共享机制在竞争线程间分配 CPU 时间。而并行编程则意味着程序员可以并行使用多个专用 CPU，这需要优化以匹配内存速度、处理能力以及其他硬件附件，适用于多核 CPU 环境。

       在并行编程中，任务是独立的，执行顺序无关紧要。它们可以是功能并行（每个处理器处理其部分问题）或数据并行（处理器处理其部分数据）。适合大型问题库，或问题规模太大以至于无法在合理时间内解决。这种编程方式在多处理器系统中能够快速获得结果。

       Fork/Join 框架是 Java 并发 API 的一部分，包含支持并行编程的类和接口。它简化了多线程创建与使用过程，并自动化了进程间的数据分配。与多线程相比，Fork/Join 框架针对多个处理器环境优化，采用递归分治策略实现并行处理。

       该框架包含四个核心类：ForkJoinTask、ForkJoinPool、RecursiveAction 和 RecursiveTask。ForkJoinTask 是抽象任务类，用于定义并行任务，ForkJoinPool 是任务执行的公共池，RecursiveAction 和 RecursiveTask 分别用于创建不返回结果或具有结果的任务。

       Fork/Join 框架采用递归分治策略，将任务拆分至更小部分，直至每个单元问题可由多核处理器并行执行。这种方式与非并行环境下的顺序处理形成鲜明对比，显著提升效率。然而，并非所有问题都适合并行处理，但许多数据数组、集合和分组问题通常与并行编程策略兼容。拼多多安全源码

       综上所述，Fork/Join 框架在 Java 中提供了实现并行编程的强大支持。正确使用并行编程技术，可以有效提升程序性能，但在实际应用中需要考虑负载平衡、任务通信等复杂因素。正确选择并行编程策略与 API，可以实现最佳性能。

java中Fork-Join框架原理及应用

       在处理大数据量任务时，使用Java中的Fork-Join框架能大幅提升效率。

       一、使用场景

       当面对大规模任务，如对大量元素数组进行排序或者需要大量资源同步执行的复杂操作，Fork-Join框架能够将任务拆分成较小部分，并行处理，最后整合结果。以数组排序为例，任务被分解为多个较小的排序任务，这些任务由多个线程并行执行，大幅提高了处理效率。

       二、基本思想

       Fork-Join框架基于分治算法原理。它将大规模任务递归分解为更小的子任务，子任务之间并行执行，最后将结果合并，实现快速有效解决大型任务。

       三、工作逻辑

       每个工作线程内部维护双端队列存储任务。任务通过fork产生并加入队尾，线程在处理本队列同时尝试窃取其他线程任务。此过程确保任务被动态分配给工作线程，且通过并发执行提高效率。

       ForkJoin包含三个关键方法：fork（启动新线程执行任务），join（等待子任务完成），compute（拆解和执行任务）。通过这三种操作，ForkJoin框架实现高效并行任务执行。

       代码实现上通常包括QTask.java模板，展示了任务执行逻辑。

       四、是否使用fork vs invokeAll

       Fork-Join框架相较于仅使用fork操作，引入invokeAll方法更方便同步子任务，简化了任务执行流程。

       五、ForkJoin与线程池区别

       相较于通用线程池模型，Fork-Join框架设计更为高效和灵活。它自动管理和分配任务，无需手动初始化和关闭线程池，播放机源码减轻了编码复杂度。同时，Fork-Join框架动态任务分配能力使其实现了更为智能的任务并行。

       综上所述，Fork-Join框架提供了简单且高效的并行任务执行方法，尤其适用于大规模数据处理和复杂同步操作场景，其动态任务分配机制与线程池相比，提升了代码简洁性和执行效率。

java的fork/join任务,你写对了吗?

       从 JDK 1.7 开始，Java引入了一种新的 Fork/Join 线程池框架，旨在将大任务拆分为多个小任务并行执行，最后汇总结果。比如计算一个大数组的和，传统的单线程循环执行效率较低。通过将数组拆分为四部分并行计算，最后汇总结果，执行效率明显提升。更进一步，如果部分仍过大，继续拆分至满足最小颗粒度后进行计算，这种反复裂变形成一系列小任务，便是 Fork/Join 的工作原理。

       Fork/Join 采用分而治之的思想，将复杂任务分解为多个简单小任务，各小任务执行结果汇总后得到最终结果。这一思想在大数据领域广泛应用。接下来，让我们具体了解 Fork/Join 的用法。

       以计算 个数字组成的数组并行求和为例，使用 Fork/Join 框架进行操作。结果表明，使用 Fork/Join 方式汇总计算与传统的循环方式结果一致。为了提高效率，最小任务数组最大容量设置为，Fork/Join 对数组进行三次拆分，执行过程清晰。

       数组量越大时，采用 Fork/Join 方式计算，程序执行效率优势明显。Fork/Join 框架的核心类包括 ForkJoinPool 和 ForkJoinTask，它们协同工作，分解大任务并汇总结果。值得注意的是，ForkJoinPool 线程池与 ThreadPoolExecutor 线程池在实现原理上有显著区别，ForkJoinPool 允许线程创建新任务并挂起当前任务，从任务队列中选择子任务执行，以充分利用并行计算。

       ForkJoinPool 是通过pom看源码负责任务执行的线程池，构造方法提供了默认无参和使用 Executors 工具类创建两种方式。ForkJoinPool 实现了 Executor 和 ExecutorService 接口，支持通过多种方法提交任务。尽管 ForkJoinPool 和 ThreadPoolExecutor 在实现上不同，但二者均能有效提升线程并发执行性能。

       ForkJoinTask 是负责任务分解和合并计算的抽象类，它实现了 Future 接口，可以直接提交到线程池。ForkJoinTask 包含 fork() 和 join() 方法，分别表示任务的分拆与合并。使用 ForkJoinTask 的三个常用子类，如 RecursiveTask，通常用于有返回值的任务计算。

       综上，ForkJoinPool 提供了一种补充线程池，通过存放任务队列和并行计算，进一步提升性能。ForkJoinTask 与 ForkJoinPool 搭配使用，将大计算任务拆分成互不干扰的小任务提交给线程池计算，最后汇总结果，实现与单线程执行相同的结果。当任务量越大，Fork/Join 框架的执行效率优势越明显。然而，并非所有任务都适合使用 Fork/Join 框架，例如 IO 密集型任务。

java源文件是什么源文件是什么

       关于java源文件是什么，源文件是什么这个很多人还不知道，今天来为大家解答以上的问题，现在让我们一起来看看吧！

       1、源文件一般指用汇编语言或高级语言写出来的代码保存为文件后的结果。

       2、源文件是相对目标文件和可执行文件而言的。

       3、源文件就是用汇编语言或高级语言写出来的代码保存为文件后的结果。

       4、目标文件是指源文件经过编译程序产生的能被cpu直接识别二进制文件。

       5、可执行文件就是将目标文件连接后形成的可执行文件，当然也是二进制的。

       6、现行源文件是指处理机正在运行进程或作业的源文件。

       7、由于程序运行具有局部性，现行源文件只有一部分调入内存，当内存缺失有关指令和数据，处理机再从外存调入有关的android源码脚本之家源文件。

       8、文件类型（或文件格式）是指电脑为了存储信息而使用的对信息的特殊编码方式，是用于识别内部储存的资料。

       9、比如有的储存，有的储存程序，有的储存文字信息。

       、每一类信息，都可以一种或多种文件格式保存在电脑存储中。

       、每一种文件格式通常会有一种或多种扩展名可以用来识别，但也可能没有扩展名。

       、扩展名可以帮助应用程序识别的文件格式。

       、扩展资料源文件类型文本文件文本文件是一种计算机文件，它是一种典型的顺序文件，其文件的逻辑结构又属于流式文件。

       、特别的是，文本文件是指以ASCII码方式(也称文本方式)存储的文件，更确切地说，英文、数字等字符存储的是ASCII码，而汉字存储的是机内码。

       、文本文件中除了存储文件有效字符信息（包括能用ASCII码字符表示的回车、换行等信息）外，不能存储其他任何信息。

       、ASCIIASCII标准使得只含有ASCII字符的文本文件可以在Unix、Macintosh、MicrosoftWindows、DOS和其它操作系统之间自由交互，而其它格式的文件是很难做到这一点的。

       、但是，在这些操作系统中，换行符并不相同，处理非ASCII字符的方式也不一致。

       、MIME文本文件在MIME标准中的类型为“text/plain”，此外，它通常还附加编码的信息。

       、在Mac OS X出现前，当Resource fork指定某一个文件的类型为“TEXT”时，Mac OS就认为这个文件是文本文件。

       、在Windows中，当一个文件的扩展名为“txt”时，系统就认为它是一个文本文件。

       、此外，处于特殊的目的，有些文本文件使用其它的扩展名。

       、例如，计算机的源代码也是文本文件，它们的后缀是用来指明它的程序语言的。

       、.txt.txt是包含极少格式信息的文字文件的扩展名。

       、.txt格式并没有明确的定义，它通常是指那些能够被系统终端或者简单的文本编辑器接受的格式。

       、任何能读取文字的程序都能读取带有.txt扩展名的文件，因此，通常认为这种文件是通用的、跨平台的。

       、在英文文本文件中，ASCII字符集是最为常见的格式，而且在许多场合，它也是默认的格式。

       、对于带重音符号的和其它的非ASCII字符，必须选择一种字符编码。

       、在很多系统中，字符编码是由计算机的区域设置决定的。

       、常见的字符编码包括支持许多欧洲语言的ISO -1。

       、由于许多编码只能表达有限的字符，通常它们只能用于表达几种语言。

       、Unicode制定了一种试图能够表达所有已知语言的标准，Unicode字符集非常大，它囊括了大多数已知的字符集。

       、Unicode有多种字符编码，其中最常见的是UTF-8，这种编码能够向后兼容ASCII，相同内容的的ASCII文本文件和UTF-8文本文件完全一致。

       、 参考资料来源  百度百科-源程序文件类型。

Java并发编程：Fork/Join框架解释

       分治算法是一种策略，将复杂问题分解为较小、相似的子问题，递归解决后合并解。步骤包括分解、解决子问题与合并。

       Fork/Join框架在Java中实现分治思想，用以高效执行并行任务。传统线程池存在效率瓶颈，Fork/Join框架提供了解决方案。

       ForkJoin框架的核心是ForkJoinTask抽象类，它用于定义任务。此框架主要特点包括任务的分解、并行执行与结果合并。

       以查找最大数组值为例，该过程可直观展示Fork/Join框架的运用。

       方法流程如下：首先使用fork方法将任务分解，然后调用join方法等待结果，invoke方法则代表fork与join的结合，即先分解后等待结果。

       具体步骤：invoke方法等同于fork后调用join，join负责检查任务是否完成，若有结果立即返回，否则阻塞至任务完成。若不先执行fork直接join，则任务将无限阻塞。

如何fork一个JAVA进程

       package b;

       import java.util.concurrent.ExecutorService;

       import java.util.concurrent.Executors;

       import javax.net.ssl.TrustManager;

       public class random5 extends Thread{

        private int id;

        public random5(int i) {

        id=i;

        // TODO 自动生成的构造函数存根

        }

        public synchronized void run(){

        int j,k,n;

        long sm;

        float x;

        j=0;

        k=0;

        sm=0;

        n=;

        //System.err.println("第"+(id+1)+"个进程启动：");

        do

        {

        x=(float)Math.random();

        j++;

        } while(x>1f/n);

        sm+=j;

        /

*

        if (j>){

        System.out.println("="+j);

        k++;

        }

        */

        System.out.println("第"+(id+1)+"个进程结束，共抽"+j+"次");

        }

       public static void main(String[]args){

        int i;

        final int n=;

        random5 []r=new random5[n];

        ExecutorService pool = Executors.newCachedThreadPool();

        //创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口

        for(i=0;i<n;i++){

        synchronized(""+i){

        r[i]=new random5(i);

        pool.execute(r[i]);

        }

        }

        pool.shutdown();

        System.out.println("===========");

        //System.out.println(k+"\n"+sm+"\n"+*+"\n"+f/sm);

        }

       }

java线程池(一)：java线程池基本使用及Executors

       @[toc] 在前面学习线程组的时候就提到过线程池。实际上线程组在我们的日常工作中已经不太会用到，但是线程池恰恰相反，是我们日常工作中必不可少的工具之一。现在开始对线程池的使用，以及底层ThreadPoolExecutor的源码进行分析。

1.为什么需要线程池

       我们在前面对线程基础以及线程的生命周期有过详细介绍。一个基本的常识就是，线程是一个特殊的对象，其底层是依赖于JVM的native方法，在jvm虚拟机内部实现的。线程与普通对象不一样的地方在于，除了需要在堆上分配对象之外，还需要给每个线程分配一个线程栈、以及本地方法栈、程序计数器等线程的私有空间。线程的初始化工作相对于线程执行的大多数任务而言，都是一个耗时比较长的工作。这与数据库使用一样。有时候我们连接数据库，仅仅只是为了执行一条很小的sql语句。但是在我们日常的开发工作中，我们的绝大部分工作内容，都会分解为一个个短小的执行任务来执行。这样才能更加合理的复用资源。这种思想就与我们之前提到的协程一样。任务要尽可能的小。但是在java中，任务不可能像协程那样拆分得那么细。那么试想，如果说，有一个已经初始化好的很多线程，在随时待命，那么当我们有任务提交的时候，这些线程就可以立即工作，无缝接管我们的任务请求。那么效率就会大大增加。这些个线程可以处理任何任务。这样一来我们就把实际的任务与线程本身进行了解耦。从而将这些线程实现了复用。 这种复用的一次创建，可以重复使用的池化的线程对象就被成为线程池。 在线程池中，我们的线程是可以复用的，不用每次都创建一个新的线程。减少了创建和销毁线程的时间开销。 同时，线程池还具有队列缓冲策略，拒绝机制和动态线程管理。可以实现线程环境的隔离。当一个线程有问题的时候，也不会对其他的线程造成影响。 以上就是我们使用线程池的原因。一句话来概括就是资源复用，降低开销。

2.java中线程池的实现

       在java中，线程池的主要接口是Executor和ExecutorService在这两个接口中分别对线程池的行为进行了约束，最主要的是在ExecutorService。之后，线程池的实际实现类是AbstractExecutorService类。这个类有三个主要的实现类，ThreadpoolExecutorService、ForkJoinPool以及DelegatedExecutorService。

       后面我们将对这三种最主要的实现类的源码以及实现机制进行分析。

3.创建线程的工厂方法Executors

       在java中， 已经给我们提供了创建线程池的工厂方法类Executors。通过这个类以静态方法的模式可以为我们创建大多数线程池。Executors提供了5种创建线程池的方式，我们先来看看这个类提供的工厂方法。

3.1 newFixedThreadPool/** * Creates a thread pool that reuses a fixed number of threads * operating off a shared unbounded queue.At any point, at most * { @code nThreads} threads will be active processing tasks. * If additional tasks are submitted when all threads are active, * they will wait in the queue until a thread is available. * If any thread terminates due to a failure during execution * prior to shutdown, a new one will take its place if needed to * execute subsequent tasks.The threads in the pool will exist * until it is explicitly { @link ExecutorService#shutdown shutdown}. * * @param nThreads the number of threads in the pool * @return the newly created thread pool * @throws IllegalArgumentException if { @code nThreads <= 0} */public static ExecutorService newFixedThreadPool(int nThreads) { return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>());}

       这个方法能够创建一个固定线程数量的无界队列的线程池。参数nthreads是最多可同时处理的活动的线程数。如果在所有线程都在处理任务的情况下，提交了其他的任务，那么这些任务将处于等待队列中。直到有一个线程可用为止。如果任何线程在关闭之前的执行过程中，由于失败而终止，则需要在执行后续任务的时候，创建一个新的线程来替换。线程池中的所有线程都将一直存在，直到显示的调用了shutdown方法。 上述方法能创建一个固定线程数量的线程池。内部默认的是使用LinkedBlockingQueue。但是需要注意的是，这个LinkedBlockingQueue底层是链表结构，其允许的最大队列长度为Integer.MAX_VALUE。

public LinkedBlockingQueue() { this(Integer.MAX_VALUE);}

       这样在使用的过程中如果我们没有很好的控制，那么就可能导致内存溢出，出现OOM异常。因此这种方式实际上已经不被提倡。我们在使用的过程中应该谨慎使用。 newFixedThreadPool(int nThreads, ThreadFactory threadFactory)方法：

/** * Creates a thread pool that reuses a fixed number of threads * operating off a shared unbounded queue, using the provided * ThreadFactory to create new threads when needed.At any point, * at most { @code nThreads} threads will be active processing * tasks.If additional tasks are submitted when all threads are * active, they will wait in the queue until a thread is * available.If any thread terminates due to a failure during * execution prior to shutdown, a new one will take its place if * needed to execute subsequent tasks.The threads in the pool will * exist until it is explicitly { @link ExecutorService#shutdown * shutdown}. * * @param nThreads the number of threads in the pool * @param threadFactory the factory to use when creating new threads * @return the newly created thread pool * @throws NullPointerException if threadFactory is null * @throws IllegalArgumentException if { @code nThreads <= 0} */public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) { return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>(),threadFactory);}

       这个方法与3.1中newFixedThreadPool(int nThreads)的方法的唯一区别就是，增加了threadFactory参数。在前面方法中，对于线程的创建是采用的默认实现Executors.defaultThreadFactory()。而在此方法中，可以根据需要自行定制。

3.2 newSingleThreadExecutor/** * Creates an Executor that uses a single worker thread operating * off an unbounded queue. (Note however that if this single * thread terminates due to a failure during execution prior to * shutdown, a new one will take its place if needed to execute * subsequent tasks.)Tasks are guaranteed to execute * sequentially, and no more than one task will be active at any * given time. Unlike the otherwise equivalent * { @code newFixedThreadPool(1)} the returned executor is * guaranteed not to be reconfigurable to use additional threads. * * @return the newly created single-threaded Executor */public static ExecutorService newSingleThreadExecutor() { return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>()));}

       此方法将会创建指有一个线程和一个无届队列的线程池。需要注意的是，如果这个执行线程在执行过程中由于失败而终止，那么需要在执行后续任务的时候，用一个新的线程来替换。 那么这样一来，上述线程池就能确保任务的顺序性，并且在任何时间都不会有多个线程处于活动状态。与newFixedThreadPool(1)不同的是，使用newSingleThreadExecutor返回的ExecutorService不能被重新分配线程数量。而使用newFixExecutor(1)返回的ExecutorService，其活动的线程的数量可以重新分配。后面专门对这个问题进行详细分析。 newSingleThreadExecutor(ThreadFactory threadFactory) 方法：

/** * Creates an Executor that uses a single worker thread operating * off an unbounded queue, and uses the provided ThreadFactory to * create a new thread when needed. Unlike the otherwise * equivalent { @code newFixedThreadPool(1, threadFactory)} the * returned executor is guaranteed not to be reconfigurable to use * additional threads. * * @param threadFactory the factory to use when creating new * threads * * @return the newly created single-threaded Executor * @throws NullPointerException if threadFactory is null */public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) { return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>(),threadFactory));}

       这个方法与3.3中newSingleThreadExecutor的区别就在于增加了一个threadFactory。可以自定义创建线程的方法。

3.3 newCachedThreadPool/** * Creates a thread pool that creates new threads as needed, but * will reuse previously constructed threads when they are * available.These pools will typically improve the performance * of programs that execute many short-lived asynchronous tasks. * Calls to { @code execute} will reuse previously constructed * threads if available. If no existing thread is available, a new * thread will be created and added to the pool. Threads that have * not been used for sixty seconds are terminated and removed from * the cache. Thus, a pool that remains idle for long enough will * not consume any resources. Note that pools with similar * properties but different details (for example, timeout parameters) * may be created using { @link ThreadPoolExecutor} constructors. * * @return the newly created thread pool */public static ExecutorService newCachedThreadPool() { return new ThreadPoolExecutor(0, Integer.MAX_VALUE,L, TimeUnit.SECONDS,new SynchronousQueue<Runnable>());}

       这个方法用来创建一个线程池，该线程池可以根据需要自动增加线程。以前的线程也可以复用。这个线程池通常可以提高很多执行周期短的异步任务的性能。对于execute将重用以前的构造线程。如果没有可用的线程，就创建一个 新的线程添加到pool中。秒内，如果该线程没有被使用，则该线程将会终止，并从缓存中删除。因此，在足够长的时间内，这个线程池不会消耗任何资源。可以使用ThreadPoolExecutor构造函数创建具有类似属性但是详细信息不同的线程池。 ?需要注意的是，这个方法创建的线程池，虽然队列的长度可控，但是线程的数量的范围是Integer.MAX_VALUE。这样的话，如果使用不当，同样存在OOM的风险。比如说，我们使用的每个任务的耗时比较长，任务的请求又非常快，那么这样势必会造成在单位时间内创建了大量的线程。从而造成内存溢出。 newCachedThreadPool(ThreadFactory threadFactory)方法：

/** * Creates a thread pool that creates new threads as needed, but * will reuse previously constructed threads when they are * available, and uses the provided * ThreadFactory to create new threads when needed. * @param threadFactory the factory to use when creating new threads * @return the newly created thread pool * @throws NullPointerException if threadFactory is null */public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) { return new ThreadPoolExecutor(0, Integer.MAX_VALUE,L, TimeUnit.SECONDS,new SynchronousQueue<Runnable>(),threadFactory);}

       这个方法区别同样也是在于，增加了threadFactory可以自行指定线程的创建方式。

2.4 newScheduledThreadPool/** * Creates a thread pool that can schedule commands to run after a * given delay, or to execute periodically. * @param corePoolSize the number of threads to keep in the pool, * even if they are idle * @return a newly created scheduled thread pool * @throws IllegalArgumentException if { @code corePoolSize < 0} */public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) { return new ScheduledThreadPoolExecutor(corePoolSize);}

       创建一个线程池，该线程池可以将任务在指定的延迟时间之后运行。或者定期运行。这个方法返回的是ScheduledThreadPoolExecutor。这个类是ThreadPoolExecutor的子类。在原有线程池的的基础之上，增加了延迟和定时功能。我们在后面分析了ThreadPoolExecutor源码之后，再来分析这个类的源码。 与之类似的方法：

/** * Creates a thread pool that can schedule commands to run after a * given delay, or to execute periodically. * @param corePoolSize the number of threads to keep in the pool, * even if they are idle * @param threadFactory the factory to use when the executor * creates a new thread * @return a newly created scheduled thread pool * @throws IllegalArgumentException if { @code corePoolSize < 0} * @throws NullPointerException if threadFactory is null */public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory) { return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);}

       通过这个方法，我们可以指定threadFactory。自定义线程创建的方式。 同样，我们还可以只指定一个线程：

public static ScheduledExecutorService newSingleThreadScheduledExecutor() { return new DelegatedScheduledExecutorService(new ScheduledThreadPoolExecutor(1));}public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) { return new DelegatedScheduledExecutorService(new ScheduledThreadPoolExecutor(1, threadFactory));}

       上述两个方法都可以实现这个功能，但是需要注意的是，这两个方法的返回在外层包裹了一个包装类。

3.5 newWorkStealingPool

       这种方式是在jdk1.8之后新增的。我们先来看看其源码：

public LinkedBlockingQueue() { this(Integer.MAX_VALUE);}0

       这个方法实际上返回的是ForkJoinPool。该方法创建了一