Juc并发编程12——2万字深入源码：线程池这篇真的讲解的透透的了

桃扇骨 2023-09-29 14:54 19阅读 0赞

本文将介绍常见的线程池的使用方法，介绍线程池的参数、拒绝策略、返回参数获取以及定时调度。

#### 2万字深入源码：线程池这篇真的讲解的透透的了 ####

*   *  1.线程池介绍
     *  2.线程池的使用
     *   *  2.1 构造方法参数详解
         *  2.2 线程池使用示例
         *  2.3 线程池的拒绝策略
         *  2.4 线程创建工厂
         *  2.5 线程异常
     *  3.使用Executors创建线程池
     *   *  3.1 newFixedThreadPool
         *  3.2 newSingleThreadExecutor
         *  3.3 newCachedThreadPool
     *  4.返回执行结果的任务
     *  5.执行定时任务

### 1.线程池介绍 ###

利用多线程我们可以合理的利用cpu资源，更加高效的完成工作，不过如果我们频繁的创建、销毁线程，也会对系统的资源造成消耗。

因此，我们也可以利用池化技术，就像数据库的连接池一样，使用线程池来管理多个线程，不对这些线程进行销毁，然后反复的使用这些线程。在`Tomcat`服务器中，可能同一时间服务器会收到大量的请求，频繁的创建、销毁线程肯定不可行，因此就使用了线程池技术。

线程池一般具有容量限制，如果所有的线程都处于工作状态，在接受到新的多线程请求时，将会进入阻塞状态，直到有可用的空闲线程，实际上就是使用**阻塞队列**处理的。

![在这里插入图片描述][2fbf0659ce6944e6ac6368f473fc35b3.png]

### 2.线程池的使用 ###

#### 2.1 构造方法参数详解 ####

我们可以使用`ThreadPoolExecutor`对象来创建线程池，先看看它的构造方法。

public ThreadPoolExecutor(int corePoolSize,
                                  int maximumPoolSize,
                                  long keepAliveTime,
                                  TimeUnit unit,
                                  BlockingQueue<Runnable> workQueue,
                                  ThreadFactory threadFactory,
                                  RejectedExecutionHandler handler) {
        
            if (corePoolSize < 0 ||
                maximumPoolSize <= 0 ||
                maximumPoolSize < corePoolSize ||
                keepAliveTime < 0)
                throw new IllegalArgumentException();
            if (workQueue == null || threadFactory == null || handler == null)
                throw new NullPointerException();
            this.acc = System.getSecurityManager() == null ?
                    null :
                    AccessController.getContext();
            this.corePoolSize = corePoolSize;
            this.maximumPoolSize = maximumPoolSize;
            this.workQueue = workQueue;
            this.keepAliveTime = unit.toNanos(keepAliveTime);
            this.threadFactory = threadFactory;
            this.handler = handler;
        }

解释下上面的参数。

*  `corePoolSize`：核心线程容量，如果需要使用一个线程，当未达到线程池核心线程容量前，不管有没有空闲的线程，都会创建一个新的线程。也可以使用`prestartCoreThread`在一开始就一次性完成所有核心线程的创建。
 *  `workQueue`:等待队列，如果需要使用一个线程，当corePoolSize的线程满了，而且没有空闲线程时，线程将会进入等待队列。
 *  `maximumPoolSize`:最大线程池容量，如果等待队列满了，需要使用一个线程时，会直接创建一个新的非核心线程，但创建的线程不可以超过`maximumPoolSize`。
 *  `handler`:如果又来一个新的任务，此时连最大线程池容量也满了，就需要使用handler来值性拒绝策略。
 *  `keepAliveTime`:非核心线程空闲后的存活时间，当非核心线程空闲超过这个时间后就会被销毁。
 *  `unit`：keepAliveTime的时间单位。
 *  `threadFactory`:线程创建工厂，我们可以干涉线程创建的过程，自定义线程的创建。

了解了`ThreadPoolExecutor`的构造方法后，我们会发现，线程池大小的限定是很重要的，合理的线程池大小的设置会使线程池的执行效率事半功倍。如何合理设置呢？

首先，线程任务有两种类型:**cpu密集型任务**和**I/O密集型任务**。

*  cpu密集型：频繁需要使用cpu的计算任务，这种任务的cpu利用率很高，空闲时间较少，可以设置最大同时运行线程数=cpu核心数。比如i5-9400F处理器的核心数为6，可以将cpu最大线程数设置为6。
 *  I/O密集型：主要是执行I/O操作的任务，比如从硬盘中读取数据，因为I/O的速度比cpu要慢很多，这种类型的任务cpu空间时间较多，可以设置最大同时运行线程数=cpu核心数\*2，让更多的线程执行I/O，提高cpu的利用率。

#### 2.2 线程池使用示例 ####

好了，万事俱备，只欠东风，现在我们来正式创建一个线程池看看效果吧。我们这里使用一个参数少点的构造方法。

public ThreadPoolExecutor(int corePoolSize,
                                  int maximumPoolSize,
                                  long keepAliveTime,
                                  TimeUnit unit,
                                  BlockingQueue<Runnable> workQueue) {
        
            this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
                 Executors.defaultThreadFactory(), defaultHandler);
        }

来。

public static void main(String[] args) throws InterruptedException {
        
            //corePoolSize:2 ;maximumPoolSize:4; keepAliveTime:3s;workQueueSize:2
            ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 4, 3, TimeUnit.SECONDS, new ArrayBlockingQueue<>(2));
            for (int i = 0; i < 6; i++) {
        
                int finalI = i;
                executor.execute(() -> {
        
                    System.out.println("prepare to execute thread :" + finalI);
                    try {
        
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException exception) {
        
                        exception.printStackTrace();
                    }
                    System.out.println("finish to execute thread :" + finalI);
                });
            }
    
            TimeUnit.SECONDS.sleep(1);
            System.out.println("pool size:" + executor.getPoolSize()); //查看当前线程池中线程数,此时应该最多有4个线程，因为线程池最大容量是4
            TimeUnit.SECONDS.sleep(5); //keepAliveTime已过
            System.out.println("pool size:" + executor.getPoolSize());
        }

其输出如下。  
![在这里插入图片描述][91bb484a25ad422498b8b9ae20cd92c3.png]  
我们看看i的输出顺序，似乎有点奇怪，我们来分析下。首先i为0，1的线程会先执行，其次i为3，4的线程进入等待队列，最后i为5，6的线程直接对线程池扩容执行，此时线程池满，i为3，4的线程等待有空闲线程时才会执行。所以就是0145先执行，23后执行。至于0，1，4，5或2，3两组内部的执行顺序这里留个坑。

我们还会发现，上面的程序怎么不退出呢？这是因为我们没有销毁线程池。里面的核心线程会一直处于等待状态。来关闭下。

public static void main(String[] args) throws InterruptedException {
        
            //
            ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 4, 3, TimeUnit.SECONDS, new ArrayBlockingQueue<>(2));
            for (int i = 0; i < 6; i++) {
        
                int finalI = i;
                executor.execute(() -> {
        
                    System.out.println("prepare to execute thread " + finalI);
                    try {
        
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException exception) {
        
                        exception.printStackTrace();
                    }
                    System.out.println("finish to execute thread " + finalI);
                });
            }
    
            TimeUnit.SECONDS.sleep(1);
            System.out.println("pool size:" + executor.getPoolSize());
            TimeUnit.SECONDS.sleep(5);
            System.out.println("pool size:" + executor.getPoolSize());
    
            executor.shutdownNow(); //关闭线程池，取消等待队列中的任务，试图终止正在执行的任务，不再接收新的任务
            // executor.shutdown(); 执行完等待队列中的任务再关闭
        }

上面我们等待队列使用的是容量为2的`ArrayBlockingQueue`,我们把它换成`SynchronousQueue`看看会发生什么？

public static void main(String[] args) throws InterruptedException {
        
            //
            ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 4, 3, TimeUnit.SECONDS, new SynchronousQueue<>());
            for (int i = 0; i < 6; i++) {
        
                int finalI = i;
                executor.execute(() -> {
        
                    System.out.println("prepare to execute thread " + finalI);
                    try {
        
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException exception) {
        
                        exception.printStackTrace();
                    }
                    System.out.println("finish to execute thread " + finalI);
                });
            }
    
            TimeUnit.SECONDS.sleep(1);
            System.out.println("pool size:" + executor.getPoolSize());
            TimeUnit.SECONDS.sleep(5);
            System.out.println("pool size:" + executor.getPoolSize());
    
            executor.shutdownNow();
        }

输出如下。  
![在这里插入图片描述][ccae4cb197fa45d1b108e003d1798218.png]在线程0，1，2，3执行完后，报出来的异常信息是`java.util.concurrent.RejectedExecutionException`，它执行了拒绝策略。我们来分析下，首先1，2执行没问题，3，4首先想要进入等待队列，不过`SynchronousQueue`根本没有容量，相当于等待队列满了，因此开始进行创建新的线程池，等5，6来时，线程池已经达到最大的线程数，因此执行了拒绝策略。这里的默认拒绝策略使用的是抛出异常。我们也可以修改。并且上面的程序不会退出，原因是啥笔者还没有弄明白，如果有大佬知道欢迎在评论区不吝赐教哟。

#### 2.3 线程池的拒绝策略 ####

线程池的拒绝策略有以下几个。

*  `AbortPolicy`: 直接抛出异常
 *  `CallerRunsPolicy`:让提交任务的线程去执行任务(比如上面的线程任务都是主线程提交的)。
 *  `DiscardOldestPolicy`:将最早进入等待队列中的任务丢弃。
 *  `DiscardPolicy`：啥也不做，直接拒绝

先来测试下`CallerRunsPolicy`

public static void main(String[] args) throws InterruptedException {
        
            ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 4, 3, TimeUnit.SECONDS, new SynchronousQueue<>(), new ThreadPoolExecutor.CallerRunsPolicy());
            for (int i = 0; i < 6; i++) {
        
                int finalI = i;
                executor.execute(() -> {
        
                    System.out.println("prepare to execute thread i:"+ finalI  + " ,name:"+ Thread.currentThread().getName());
                    try {
        
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException exception) {
        
                        exception.printStackTrace();
                    }
                    System.out.println("finish to execute thread " + finalI  + " ,name:"+Thread.currentThread().getName());
                });
            }
    
            TimeUnit.SECONDS.sleep(1);
            System.out.println("pool size:" + executor.getPoolSize());
            TimeUnit.SECONDS.sleep(5);
            System.out.println("pool size:" + executor.getPoolSize());
    
            executor.shutdownNow();
        }

其执行结果如下。  
![在这里插入图片描述][b164cc16a3fc48e297884e73a8226c97.png]  
可以看到i为4的线程确实是由主线程执行的哟。等它在主线程执行完的时候，正好线程池也有空闲线程了，因此就又可以让线程池的线程执行任务了。

接下来演示下`DiscardOldestPolicy`。

public static void main(String[] args) throws InterruptedException {
        
            ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 4, 3, TimeUnit.SECONDS, new ArrayBlockingQueue<>(2), new ThreadPoolExecutor.DiscardOldestPolicy());
            for (int i = 0; i < 7; i++) {
        
                int finalI = i;
                executor.execute(() -> {
        
                    System.out.println("prepare to execute thread i:"+ finalI );
                    try {
        
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException exception) {
        
                        exception.printStackTrace();
                    }
                    System.out.println("finish to execute thread " + finalI );
                });
            }
    
            TimeUnit.SECONDS.sleep(1);
            System.out.println("pool size:" + executor.getPoolSize());
            TimeUnit.SECONDS.sleep(5);
            System.out.println("pool size:" + executor.getPoolSize());
    
            executor.shutdownNow();
        }

其输出如下。  
![在这里插入图片描述][494be3b8d6d54db890667c3cef49de41.png]  
Thread2没有执行，这是因为它是最早进入等待队列的，在最后一个任务提交时，使用拒绝策略`DiscardOldestPolicy`将其取消了。

如果使用`SynchronousQueue`做等待队列，`DiscardOldestPolicy`做拒绝策略，会出现什么情况呢？

public static void main(String[] args) throws InterruptedException {
        
            ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 4, 3, TimeUnit.SECONDS, new SynchronousQueue<>(), new ThreadPoolExecutor.DiscardOldestPolicy());
            for (int i = 0; i < 6; i++) {
        
                int finalI = i;
                executor.execute(() -> {
        
                    System.out.println("prepare to execute thread i:"+ finalI );
                    try {
        
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException exception) {
        
                        exception.printStackTrace();
                    }
                    System.out.println("finish to execute thread " + finalI );
                });
            }
    
            TimeUnit.SECONDS.sleep(1);
            System.out.println("pool size:" + executor.getPoolSize());
            TimeUnit.SECONDS.sleep(5);
            System.out.println("pool size:" + executor.getPoolSize());
    
            executor.shutdownNow();
        }

输出结果如下。  
![在这里插入图片描述][c516e4823608468da11c87628050ae0a.png]居然直接爆栈了。为什么呢？我们得看看它的源码了。

public static class DiscardOldestPolicy implements RejectedExecutionHandler {
        
          
            public DiscardOldestPolicy() {
         }
    
            public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        
                if (!e.isShutdown()) {
         //如果线程池没有关闭
                    e.getQueue().poll(); //将等待队列队顶中元素出队
                    e.execute(r); //再调用线程池的execute方法
                }
            }
        }

原因找到了，原来`e.getQueue().poll()`对于`SynchronousQueue`没有任何的意义，它会陷入死循环，一遍遍的执行`execute`，再执行拒绝策略，最后导致栈溢出。

最后演示下`DiscardPolicy`。

public static void main(String[] args) throws InterruptedException {
        
            ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 4, 3, TimeUnit.SECONDS, new SynchronousQueue<>(), new ThreadPoolExecutor.DiscardPolicy());
            for (int i = 0; i < 6; i++) {
        
                int finalI = i;
                executor.execute(() -> {
        
                    System.out.println("prepare to execute thread i:"+ finalI );
                    try {
        
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException exception) {
        
                        exception.printStackTrace();
                    }
                    System.out.println("finish to execute thread " + finalI );
                });
            }
    
            TimeUnit.SECONDS.sleep(1);
            System.out.println("pool size:" + executor.getPoolSize());
            TimeUnit.SECONDS.sleep(5);
            System.out.println("pool size:" + executor.getPoolSize());
    
            executor.shutdownNow();
        }

结果如下。真的太简单了，不讲解了。  
![在这里插入图片描述][eb6e15cea1eb498f8d89cd7738abfa1a.png]  
除了官方提供的拒绝策略外，我们也可以使用自定义的拒绝策略哟。

public static void main(String[] args) throws InterruptedException {
        
            ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 4, 3, TimeUnit.SECONDS, new SynchronousQueue<>(), (r, e) -> {
        
                System.out.println("full,full,full!");
                r.run(); //直接在当前的(调用提交方法所在)线程运行
            });
            for (int i = 0; i < 6; i++) {
        
                int finalI = i;
                executor.execute(() -> {
        
                    System.out.println("prepare to execute thread i:" + finalI + " ,name:" + Thread.currentThread().getName());
                    try {
        
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException exception) {
        
                        exception.printStackTrace();
                    }
                    System.out.println("finish to execute thread " + finalI + " ,name:" + Thread.currentThread().getName());
                });
            }
    
            TimeUnit.SECONDS.sleep(1);
            System.out.println("pool size:" + executor.getPoolSize());
            TimeUnit.SECONDS.sleep(5);
            System.out.println("pool size:" + executor.getPoolSize());
    
            executor.shutdownNow();
        }

运行的结果如下。  
![在这里插入图片描述][990b2108b2ac4dad9cb42c2a7ce509a2.png]

#### 2.4 线程创建工厂 ####

我们之前也提到过，我们可以利用线程创建工厂干涉线程的创建过程。

public static void main(String[] args) throws InterruptedException {
        
            ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 4, 3, TimeUnit.SECONDS, new ArrayBlockingQueue<>(2), new ThreadFactory() {
        
                int count = 0;
                @Override
                public Thread newThread(Runnable r) {
         //改变了线程的命名
                    return new Thread(r,"thread" + count++);
                }
            });
            for (int i = 0; i < 6; i++) {
        
                int finalI = i;
                executor.execute(() -> {
        
                    System.out.println("prepare to execute thread i:" + finalI + " ,name:" + Thread.currentThread().getName());
                    try {
        
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException exception) {
        
                        exception.printStackTrace();
                    }
                    System.out.println("finish to execute thread " + finalI + " ,name:" + Thread.currentThread().getName());
                });
            }
    
            TimeUnit.SECONDS.sleep(1);
            System.out.println("pool size:" + executor.getPoolSize());
            TimeUnit.SECONDS.sleep(5);
            System.out.println("pool size:" + executor.getPoolSize());
    
            executor.shutdownNow();
        }

输出结果如下。  
![在这里插入图片描述][4766f25ca833491c8420bf65634b84ef.png]

#### 2.5 线程异常 ####

如果线程池中的线程遇到异常会出现什么情况呢，会不会被销毁呢？

public static void main(String[] args) throws InterruptedException {
        
            ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 1, 0, TimeUnit.SECONDS, new LinkedBlockingDeque<>());
            executor.execute(() -> {
        
                System.out.println(Thread.currentThread().getName());
                throw new RuntimeException("error");
            });
            TimeUnit.SECONDS.sleep(1);
            executor.execute(() -> {
        
                System.out.println(Thread.currentThread().getName());
            });
        }
        executor.shutdown();

输出如下，两次输出的线程名字不同。看来线程池中抛异常的确实会被销毁哟。  
![在这里插入图片描述][3d5a9d6f366e4d27931f8d06a97e4832.png]

### 3.使用Executors创建线程池 ###

#### 3.1 newFixedThreadPool ####

除了使用new一个ThreadPoolExecutor的方法，我们还可以使用`Executors`创建一个线程池。

public static void main(String[] args) throws InterruptedException{
        
            // 创建容量固定为10的线程池
            ExecutorService service = Executors.newFixedThreadPool(10); //ThreadPoolExecutor extends AbstractExecutorService, AbstractExecutorService implements ExecutorService
            service.execute(() -> {
        
                System.out.println("hello.word");
            });
    
            service.shutdown();
        }

对比下之前的创建方式。即使是参数最少的构造方法，Executors创建也比new一个ThreadPoolExecutor更加简洁。

ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 4, 3, TimeUnit.SECONDS, new ArrayBlockingQueue<>(2));

再看看源码。就是说包装是yyds。

public static ExecutorService newFixedThreadPool(int nThreads) {
        
            return new ThreadPoolExecutor(nThreads, nThreads,
                                          0L, TimeUnit.MILLISECONDS,
                                          new LinkedBlockingQueue<Runnable>());
        }

#### 3.2 newSingleThreadExecutor ####

上面是创建容量固定为10的线程池，还可以创建使用`newSingleThreadExecutor`容量为1的线程,有点单例的感觉。

public static void main(String[] args) throws InterruptedException{
        
            ExecutorService service = Executors.newSingleThreadExecutor(); //ThreadPoolExecutor extends AbstractExecutorService, AbstractExecutorService implements ExecutorService
            for (int i = 0; i < 2; i++) {
        
                service.submit(() -> {
        
                    System.out.println(Thread.currentThread().getName() + "execute");
                    try {
        
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException exception) {
        
                        exception.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "finished");
                });
            }
    
            service.shutdown();
        }

输出如下。  
![在这里插入图片描述][2f55babfb7d04a828d16ad431f4e27f3.png]  
看看其源码。

public static ExecutorService newSingleThreadExecutor() {
        
            return new FinalizableDelegatedExecutorService
                (new ThreadPoolExecutor(1, 1,
                                        0L, TimeUnit.MILLISECONDS,
                                        new LinkedBlockingQueue<Runnable>()));
        }

里面返回的是`FinalizableDelegatedExecutorService`，并且其构造方法的参数是`ThreadPoolExecutor`对象，点进去看看到底是什么？

static class FinalizableDelegatedExecutorService
            extends DelegatedExecutorService {
        
            FinalizableDelegatedExecutorService(ExecutorService executor) {
        
                super(executor);
            }
            protected void finalize() {
        
                super.shutdown();
            }
        }

原来里面重写了`finalize`，当线程池被gc时会调用shutdown方法。将传过来的`ThreadPoolExecutor`又传给了其父类`DelegatedExecutorService`.点`super(executor)`看看里面做了什么？

static class DelegatedExecutorService extends AbstractExecutorService {
        
            private final ExecutorService e;
            DelegatedExecutorService(ExecutorService executor) {
         e = executor; }
            public void execute(Runnable command) {
         e.execute(command); }
            public void shutdown() {
         e.shutdown(); }
            public List<Runnable> shutdownNow() {
         return e.shutdownNow(); }
            public boolean isShutdown() {
         return e.isShutdown(); }
            public boolean isTerminated() {
         return e.isTerminated(); }
            ...
    }

原来最后还是调用`ExecutorService`来实现的逻辑呀。有没有代理的感觉？包装的目的主要是为了安全性。我们看看将它创建的对象强转成`ThreadPoolExecutor`。

public static void main(String[] args) throws InterruptedException{
        
       ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newSingleThreadExecutor();     
      }

报错。这是因为它根本不是ThreadPoolExecutor类型的对象。  
![在这里插入图片描述][7c0780047c444c249454b657fa212b93.png]  
如果是`newFixedThreadPool`强转运行就不会报错。

public static void main(String[] args) throws InterruptedException{
        
            ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(1);
            }

输出如下。  
![在这里插入图片描述][5dcd3938ce104fc8a0f653efa62c3bef.png]强转以后可以干什么，当然是动态修改参数了。比如。

public static void main(String[] args) throws InterruptedException{
        
            ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(1);
                    executor.setCorePoolSize(10);
        }

这样我们线程池的核心容量就改变了。想象要是`newSingleThreadExecutor`创建的对象也可以改变容量大小，它还可以称之为单线程线程池么？我们使用它来编码，不就有可能因为不知道其容量发生了变化出错吗？

#### 3.3 newCachedThreadPool ####

看看源码，newCachedThreadPool是做什么的？

public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
        
            return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                          60L, TimeUnit.SECONDS,
                                          new SynchronousQueue<Runnable>(),
                                          threadFactory);
        }

可以看出来，其核心线程数是0，最大线程数是`Integer.MAX_VALUE`，空闲等待时间是60s，等待队列没有容量。由于其最大线程数几乎可以让你想创建多少线程就创建多少线程，并且空闲线程等待时间是很长的，有60s，因此可能存在许多隐患，建议谨慎使用。

### 4.返回执行结果的任务 ###

使用`submit`方法(而不是`execute`)提交任务可以获取任务执行的返回。

先使用下面带`Callable`传参的版本的submit

<T> Future<T> submit(Callable<T> task);

来

执行结果如下。  
![在这里插入图片描述][547ac1ebaa4449428aa80cd4cea47fd0.png]  
也可以使用`submit`的下面这个带`Runnable`和`result`重载方法。

<T> Future<T> submit(Runnable task, T result);

来。

public static void main(String[] args) throws InterruptedException, ExecutionException {
        
            ExecutorService service = Executors.newSingleThreadExecutor();
            Future<String> future = service.submit(() ->{
        
                try {
        
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException exception) {
        
                    exception.printStackTrace();
                }
            }, "hello,world");
            System.out.println(future.get());
    
        }

还可以使用带`FutureTask`参数的构造方法。这种方式在`get`时是不是更加简洁一点点？

public static void main(String[] args) throws InterruptedException, ExecutionException {
        
            ExecutorService service = Executors.newSingleThreadExecutor();
            FutureTask<String> task = new FutureTask(() -> "hello,world");
            service.submit(task);
            System.out.println(task.get());
            service.shutdown();
        }

上面三种方法都可以获取任务执行的返回结果。我们还可以通过`Future`对象获取当前任务的执行状态。

输出结果如下哟。  
![在这里插入图片描述][907ba2ed40fb405a9ead5db949142865.png]如果我们不用get来阻塞的等待执行结果，输出结果还会一样吗？

不一样了哟。  
![在这里插入图片描述][66b3a126484249a9b6c21ebb0cfde281.png]  
可以在任务执行过程中取消任务。

public static void main(String[] args) throws InterruptedException, ExecutionException {
        
            ExecutorService service = Executors.newSingleThreadExecutor();
            Future<String> task = service.submit(() -> {
        
                TimeUnit.SECONDS.sleep(1);
                return "hello";
            });
            task.cancel(true);
            System.out.println(task.isDone());
            System.out.println(task.isCancelled());
            service.shutdown();
        }

执行结果如下。  
![在这里插入图片描述][763152528ce54874803d7a4307750233.png]

### 5.执行定时任务 ###

jdk5以后，可以使用`ScheduledThreadPoolExecutor`来执行定时任务，它继承自`ThreadPoolExecutor`。看看它的构造方法吧。可以发现其最大容量都是`Integer.MAX_VALUE`，并且使用的等待队列都是`DelayedWorkQueue`，是不是有种恍然大悟的感觉。

public ScheduledThreadPoolExecutor(int corePoolSize) {
        
            super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
                  new DelayedWorkQueue());
        }
    
       
        public ScheduledThreadPoolExecutor(int corePoolSize,
                                           ThreadFactory threadFactory) {
        
            super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
                  new DelayedWorkQueue(), threadFactory);
        }
    
        public ScheduledThreadPoolExecutor(int corePoolSize,
                                           RejectedExecutionHandler handler) {
        
            super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
                  new DelayedWorkQueue(), handler);
        }
    
        public ScheduledThreadPoolExecutor(int corePoolSize,
                                           ThreadFactory threadFactory,
                                           RejectedExecutionHandler handler) {
        
            super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
                  new DelayedWorkQueue(), threadFactory, handler);
        }

来使用下吧。太简单了，是不是？

public static void main(String[] args) {
        
            ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(1); //核心线程数1
            executor.schedule(() ->System.out.println("hello,world!"), 3, TimeUnit.SECONDS);
            executor.shutdown();
        }

还可以设置按照一定的频率周期来执行任务。看看源码就会用。

public static void main(String[] args) throws InterruptedException {
        
            ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(1);
            executor.scheduleAtFixedRate(() ->System.out.println("hello,world!"), 1,3, TimeUnit.SECONDS); //初始delay1s，之后每3s执行一次
            TimeUnit.SECONDS.sleep(20);
            executor.shutdown();
        }

它还有一个和上面方法很相似的方法`scheduleWithFixedDelay`。它们甚至连参数都是一毛一样。你运行下看看，会发现好像效果也是一样的。

public static void main(String[] args) throws InterruptedException {
        
            ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(1);
            executor.scheduleWithFixedDelay(() ->System.out.println("hello,world!"), 1,3, TimeUnit.SECONDS);
            TimeUnit.SECONDS.sleep(20);
            executor.shutdown();
        }

那它们到底有什么其区别呢？您再运行下下面的代码。

public static void main(String[] args) throws InterruptedException {
        
            ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(1);
            executor.scheduleWithFixedDelay(() ->{
        
                try {
        
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException exception) {
        
                    exception.printStackTrace();
                }
                System.out.println("hello,world!");
                }, 1,3, TimeUnit.SECONDS);
            TimeUnit.SECONDS.sleep(20);
            executor.shutdown();
        }

原来`scheduleAtFixedRate`是按一定的频率去执行任务，不管任务有没有执行完，而`scheduleWithFixedDelay`是在任务执行结束的基础上再delay一定时间去执行任务。

[2fbf0659ce6944e6ac6368f473fc35b3.png]: https://img-blog.csdnimg.cn/2fbf0659ce6944e6ac6368f473fc35b3.png
[91bb484a25ad422498b8b9ae20cd92c3.png]: https://img-blog.csdnimg.cn/91bb484a25ad422498b8b9ae20cd92c3.png
[ccae4cb197fa45d1b108e003d1798218.png]: https://img-blog.csdnimg.cn/ccae4cb197fa45d1b108e003d1798218.png
[b164cc16a3fc48e297884e73a8226c97.png]: https://img-blog.csdnimg.cn/b164cc16a3fc48e297884e73a8226c97.png
[494be3b8d6d54db890667c3cef49de41.png]: https://img-blog.csdnimg.cn/494be3b8d6d54db890667c3cef49de41.png
[c516e4823608468da11c87628050ae0a.png]: https://img-blog.csdnimg.cn/c516e4823608468da11c87628050ae0a.png
[eb6e15cea1eb498f8d89cd7738abfa1a.png]: https://img-blog.csdnimg.cn/eb6e15cea1eb498f8d89cd7738abfa1a.png
[990b2108b2ac4dad9cb42c2a7ce509a2.png]: https://img-blog.csdnimg.cn/990b2108b2ac4dad9cb42c2a7ce509a2.png
[4766f25ca833491c8420bf65634b84ef.png]: https://img-blog.csdnimg.cn/4766f25ca833491c8420bf65634b84ef.png
[3d5a9d6f366e4d27931f8d06a97e4832.png]: https://img-blog.csdnimg.cn/3d5a9d6f366e4d27931f8d06a97e4832.png
[2f55babfb7d04a828d16ad431f4e27f3.png]: https://img-blog.csdnimg.cn/2f55babfb7d04a828d16ad431f4e27f3.png
[7c0780047c444c249454b657fa212b93.png]: https://img-blog.csdnimg.cn/7c0780047c444c249454b657fa212b93.png
[5dcd3938ce104fc8a0f653efa62c3bef.png]: https://img-blog.csdnimg.cn/5dcd3938ce104fc8a0f653efa62c3bef.png
[547ac1ebaa4449428aa80cd4cea47fd0.png]: https://img-blog.csdnimg.cn/547ac1ebaa4449428aa80cd4cea47fd0.png
[907ba2ed40fb405a9ead5db949142865.png]: https://img-blog.csdnimg.cn/907ba2ed40fb405a9ead5db949142865.png
[66b3a126484249a9b6c21ebb0cfde281.png]: https://img-blog.csdnimg.cn/66b3a126484249a9b6c21ebb0cfde281.png
[763152528ce54874803d7a4307750233.png]: https://img-blog.csdnimg.cn/763152528ce54874803d7a4307750233.png