1.scheduledthreadpoolexecutor 初始化多少个
2.ava中有几种方法可以实现一个线程？用什么关键字修饰同步方法? stop()和suspend()方法为何不推荐使用？
3.java线程池(一)：java线程池基本使用及Executors

scheduledthreadpoolexecutor 初始化多少个

       é€šè¿‡Executors,可以创建3种类型的ThreadPoolExecutor。

       - FixedThreadPool

       - SingleThreadExecutor

       - CachedThreadPool

       1.FixedThreadPool

       FixedThreadPool被称为可重用固定线程数的线程池。下面是FixedThreadPool的源代码实现。

       public static ExecutorService newFixedThreadPool(int nThreads) {

        return new ThreadPoolExecutor(nThreads, nThreads, 0L,

        TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());

       FixedThreadPool中多余的空闲线程会被立即终止。

       FixedThreadPool的execute()运行示意图如下所示。

       å¦‚果当前运行的线程数小于corePoolSize,则创建新线程来执行任务。

       å½“前运行的线程数等于corePoolSize,将任务加入LinkedBlockingQueue。

       çº¿ç¨‹æ‰§è¡Œå®Œ1中的任务后，会反复从阻塞队列中取任务执行。

ava中有几种方法可以实现一个线程？用什么关键字修饰同步方法? stop()和suspend()方法为何不推荐使用？

       的ActiveX

        ActiveX的ActiveX起源时，最初只是一个品牌名称，它涵盖了技术不是孤立的，其中大部分是与Internet和Web有一定关联。更重要的是，在ActiveX的HTML简约企业源码整体技术是微软的COM（组件对象模型组件对象模型）的建立。但不要误认为ActiveX是定义了所有包含基于COM的技术。 COM和Microsoft Office和Windows，微软正在做相关的一切，很明显，这些产品是不是ActiveX的家庭成员。

       的ActiveX复合文档从微软的技术 - OLE成长起来的。 OLE初始释放，但针对复合文档，但在后续版本OLE2进口COM。 COM的的OLE设计师需求的诞生。其基本出发点是做一个软件，通过一个共同的机构提供服务，另一家软件。因此，COM用户OLE2。事实上，COM和复合文档，是没有多大意义的。后来，COM完全无关的复合文档技术开始得到广泛的应用。因此，微软开始“染指”通用平台技术。 COM是不是一个产品，它需要一个商标名称。不幸的是，市场专家们选择了“OLE”作为商号。然后，利用COM技术的OLE标签粘贴。当然，这些技术的绝大多数具有没有关系与化合物笔。微软为了向人们解释：“OLE不仅是指复合文档！”这是一个相当大的量的能量和时间。

       所以，在年的春天，微软改变了主意，选择了ActiveX作为一个新的品牌名称。 ActiveX是一个松散定义的基于COM的技术的集合，OLE仍然仅指复合文档。当然，最重要的核心COM。

       对象模型完全独立于编程语言，这是一个非常新颖的想法。从C + +和Java对象，我们将能够理解。但所谓的COM对象是什么就是什么呢？为了便于理解，COM可以看出一些种（软件）封装技术，可以看到它作为一个不同的软件的一部分，结合成某种形式的面向对象的，可以交互的学子商城源码过程和一组支持库。 COM对象可以被写入在C + +，Java中，和VB语言的任何DLL或文件的不同进程的工作的实施。任何语言编写的客户端使用COM对象，而不关注的对象，和不关心它的DLL，或者到另一个进程来执行。从客户端，没有任何区别。

       这样一个共同的处理方法是非常有用的。例如，两个应用程序协调运行的用户，可以合作的一部分，作为COM对象实现（当然，现在可以做的OLE复合文档）之间的相互作用。在浏览器中执行从Web服务器下载的代码，浏览器就可以看到它作为一个COM对象。换句话说，COM技术也是一种打包下载代码的标准方法（ActiveX控件执行此功能）。

       甚至是应用程序与本地操作系统交互的方法，您可以使用COM来指定新的API（Windows和Windows NT，多数被定义为一个COM对象）。 COM虽然起源于一个复合文档，但它可以被有效地应用于许多软件问题。

       的ActiveX英国

       活动平台是微软的世界观。其基本思想是：使用ActiveX控件来建立，包括从组织与用户互动和交易处理监视器，以适应COM的Web服务器，所有的自动。活动平台包括两部分：活动服务器和活动的客户端。

       活动服务器的中间层。组件或Active Server Pages，为客户提供业务逻辑和应用处理的地方。 ActiveServer技术的核心NT Server，Microsoft事务服务器，数据管理服务，目录服务，Web服务，以及网络服务。

       交易服务器是微软的基于组件的编程模型，结合了传统的TP多个线程生成和数据库监控功能。其他组件的数据管理服务，如主动OLE DB和ODBC访问DB2，甲骨文，SQL Server和其他数据源。目录服务提供目录服务层，使在网络上的远程对象的相互四处搜寻DCOM（分布式COM，分布式COM）。 Inter网服务器为中心的Web服务建立在Web服务器上，应用程序的开发，生成脚本（脚本）的机构。通过中介网络为中心的网络服务，DCOM建立MS-RPC同步，这样一来就能连接的人民棋牌源码控制。

       活跃的客户端是一个跨平台的。微软的技术，即使排斥，但也希望，这项技术是开放的多个操作系统。该计划的具体实施是使用脚本引擎（脚本引擎）。脚本引擎是一个标准的HTML和Java虚拟机（JVM）与微软特色，微软的VBScript司法人员叙用委员会RIPT的构成。组装到微软的IE 3.0和4.0的ActiveX，可以成为活跃的客户端的C / S

       从企业用户只使用Windows的Active平台可以提供一个强大的，可扩展的服务器应用程序开发平台的应用程序的一部分。 ActiveServer的TP监视器高端产品这样的场合，使用常见的工具和技术。因此，小型工作组和内联网应用程序将无法超越的Active Server的能力。 ACTI VE的目标平台是一个异构的环境，但由于过度依赖IE，所以你不能开车到客户端。虽然一些非Windows平台上也推出了浏览器，但最好的支持，最新版本的资源管理器或窗口s。

       的ActiveX进步

        COM扩展初始版本的分布式计算，假设COM对象和它的客户端运行在同一台机器（在同一个进程，而且在不同的进程），DCOM的的ActiveX家庭成员。后来，它可以使用在Windows 中。 COM对象的DCOM客户端交互不能做任何。

       客户端使用完全相同的代码可以访问本地和远程对象。然而，很多情况下，客户需要的一些DCOM附件。 DCOM提供分布式的安全保密机制，以提供验证和数据加密。发布于年，是Windows NT 5.0，Kerberos等安全保密协议，追加到DCOM。 DCOM已经能够使用简洁的域名服务，目录服务，搜索其他计算机上的COM对象。 NT 5.0支持更多的的ACTI已经指南。 Active Directory的域名服务和轻量级目录访问协议的基础上。

        DCOM的对手，一直是OMG（对象管理组织）的CORBA（公共对象R equest代理体系结构）。它被组装成IONA的Orbix和Visigenic的VisiBroker和其他产品。不久前，另一位技术支持分散的对象 - Java远程方法调用介绍。两个C ORBA，DCOM，可以在多语言写对象之间的通信。 RMI只限于Java实现对象之间的通信。很显然，这是mapnik源码解析一个制约因素。 RMI是非常简单的使用。 RMI开发人员可以使用Java来设计的协议规范。因此，在语言的功能，可以进行无缝的。

       写一个的DCOM服务器处理只有两三个客户端，是相当简单的。然而，建立一个高效的处理数百成千上万的客户端DCOM服务器，相当困难。

       为了便于编写可扩展的DCOM服务器，微软事务服务器（MTS）。在支持该交易的同时，MTS自动生成的线索和重复使用的智能对象。 MTS可伸缩的服务器的生产变得相当简单。即使没有事务处理应用程序，使用MTS也不错。事实上，M icrosoft鼓励人们使用VB写的MTS应用程序。这是发展业务服务器的传统做法不同，所有MTS应用程序的COM对象写入一个以上的，而且必须实现的一个DLL。在正常情况下，客户端将无法看到MTS。客户端只是继续生产，使用COM对象可以是。

       标准化组件的

       基于组件的应用程序的开发，组装电子设备，你可以使用现成的零部件来构建应用程序。桌面使用的ActiveX控件，基于COM的组件。所谓的ActiveX控件，但要符合一定的标准，COM对象进行交互的客户端。

       例如，ActiveX控件，必须通过自动化（调度接口）来公开方法。这种标准化的交互功能，可以使用在一个数量不同的情况下，相同的控制。 “幕后”这个标准接口，ActiveX控件是几乎能胜任。现在，许多软件公司都能够控制各种功能。

        ActiveX控件的DDL的准备，为此，它必须被加载到一个容器中。 ActiveX控件容器VB原型，此外，也有多种选择的容器。目前，一个非常重要的控制容器是微软的网络浏览器

       那些元素的所谓的ActiveX控件，它是要实现的许多方法。他们已经从本地硬盘的cps外卖源码机器VB和其他容器。数百KB和MB管制的，似乎没有什么大的区别。但是当你想控制被加载到Web浏览器，它很可能是通过电话线速度非常缓慢。现在，该大小的控制是非常关键的问题。要进行控制，超过一定限度，就会延长下载时间。因此，Microsoft提供了ActiveX控件，只有在绝对必要的功能。

       苹果公司和IBM公司推出的OpenDoc，是主要竞争对手的ActiveX控件。的OpenDoc赞助的企业现在已正式宣布暂停经济援助。与微软的企业青睐JavaBeans（J ava的基于组件的结构）的对抗。基本上是捆绑的ActiveX控件和Windows，在二进制机器代码，而JavaBeans是不同的，它是能够执行。这，当然是有代价的。很明显，只要不牺牲便携性，它是不可能完全彻底利用当地的环境。要编写的组件可以从公共互联网上下载的，应优先考虑选择JavaBeans的。

       桌面组件市场的持续快速增长。其中大部分是基于ActiveX控件的建立（Java Beans的仍是少数）。服务器组件的标准化落后。在桌面上，VB，PowerBuilder编程环境，容器，Web浏览器是强大的。如果在服务器容器是必须要做的吗？集装箱的服务器组件事务服务器是一个更好的选择。

       微软的竞争对手，并尽一切可能防止MTS和NT占领市场。他们是在全速发展标准的服务器组件，其中一个最有前途的是对En?terprise JavaBeans。 JavaBeans的扩张，并定义了一个事务处理服务器接口。 Enterprise JavaBeans的支持者，独立软件供应商，作为一个COM组件来写，但写豆类的服务器组件。

        ActiveX构建工具的

       推广的ActiveX控件，ActiveX控件的开发工具是与日俱增。由于ActiveX是不依赖于语言，传统的开发工具基本上可以建立的ActiveX控件。最常用的Delphi，宝werBuilder以及Visual Basic中的Visual C + +时，Visual J + +等。基本配置文件

        1。 ActiveX控件的3GL开发：①MFC（微软基础类，Microsoft基础类），②ActiveX模板库，ActiveX模板库（ATL），③BaseCtrl的框架等。 MFC是最经典的，使用MFC开发人员不关心的接口，而是将注意力集中在对象的动作。它的缺点是必须存在的控制和执行DLL与容器的尺寸就越大。 ATL可以使用模板来生成代码。也就是说，图书馆和DLL没有一起推出的控制。在ATL中，你需要一些基本的派生类从现有的模板。 AT L也有缺点，即该接口的处理是困难的，该应用程序的必要的接口，必须创建。此外，ATL不支持的类向导，类向导。不幸的是，没有对象描述语言（对象描述语言）和接口定义语言文件，自动同步用户代码向导。 BaseCtrl是一?个简单的类型库。 ATL是非常相似，但没有模板。事实上，由于BaseCtrl太容易了，微软不支持它。在BaseCtrl中，一些无所不能的控制（骨架控制）。该ActiveX的发展模式BaseCtrl提供容易理解的，但与ATL并不简单，是不是和ATL和灵活性。现在看来，ActiveX控件的开发人员，BaseCt RL是“苦”的选择。

        2。开发工具

        ActiveX控件可以，第一个工具的Microsoft Visual C + +。它可以提供最大程度的控制ActiveX开发。的Visual J + +和ActiveX控件也可以。

        Borland公司推出了两款工具（JBuilder和IntraBuilder），也是很可观的。然而，BORL和工具创建ActiveX组件，只有德尔福3.0和C + + Builder中。 Borland的Delphi的A ctiveX发展的特点，被称为内有效。它是任意的Delphi窗口的形式的ActiveX。活跃?在配备了新的控件在Web上。 Delphi控件COM和DCOM的链接。

        PowerBuilder的5.0转化为可用于开发的ActiveX客户端/服务器开发工具。作为一个ActiveX控件，可配鲍威的rBuilder数据窗口（PowerBuilder应用开发的核心部分）。为了使PowerBuilder开发人员现在可以使用的PowerScript编程语言，一些熟悉的功能。

       拥有最好的工具，使ActivX控件，无疑是微软。例如，使用Visual Basic 5.0中，开发人员可以使用可视化编程环境和本地语言Visual Basic应用开发控制。

        5的ActiveX

       事实上，Windows和Windows NT，ActiveX技术环境的世界。但无论MICR OSOFT以及如何推进它的操作系统，也不能所有的企业已成为所有Windows。 ，MICROS经常要尽量使COM，DCOM和ActiveX家庭的一部分，也可以使用其他OS。 Macin胡说已经支持ActiveX，这其中也包括对ActiveX控件的支持。 Software AG的这些技术被移植到多种Unix和IBM的OS/。 DEC和HP还打算在自己的系统中使用这些技术，他们也是微软的源代码移植的方式来实现。

        COM的Windows 和Windows NT环境为基础的软件已成为一个重要组成部分，但它是未来，有很多不确定因素。例如，微软是作为一个多平台的技术，能够COM开发允许继续存在呢？按企业现有的NT服务器，有必要使DCOM的分布式服务，也可以应用在非微软平台上。为了解决这些问题，它需要相当长的一段时间。基于CORBA的产品，和JAV一个RMI已经成功地运行在多操作系统环境。后期推出的多平台，DCOM，CORBA和RMI领先?的多。

        ActiveX控件和JavaBeans竞争力的前景？无论在Web浏览器或运行在另一个地方运行的软件，或在短的，组件的软件（构件的）是一种软件开发的热点。目前，ActiveX控件，暂时处于领先地位，但由于的OpenDoc的运行过程，与微软的企业竞争成为了一个与之抗衡的。用户再也不想看到“独霸天下”，仅仅这一点的，JavaBean将在此的市场竞争中抢占一席之地。

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。该方法创建了一