线程池

最新推荐文章于 2023-05-15 14:52:51 发布

_SpringBoot

最新推荐文章于 2023-05-15 14:52:51 发布

阅读量155

点赞数 1

本文链接：https://blog.csdn.net/MONKEY_Quan/article/details/89532941

版权

线程池：线程池是指一个在初始化一个多线程应用程序过程中创建一个线程集合，然后在需要执行新的任务时重用这些线程而不是新建一个线程。线程池中线程的数量通常完全取决于可用内存数量和应用程序的需求。然而，增加可用线程数量是有限的。线程池中的每个线程都有被分配一个任务，一旦任务已经完成了。线程回到池子中并等待一下一次分配任务。

为什么要创建线程池：由操作系统来创建线程、切换线程状态、终结线程都要进行CPU调度--这是一个耗费时间和系统资源的事情。大多数实际场景中是这样的：处理某一次请求的时间是非常短暂的，但是请求数量是巨大的。这种技术背景下，如果我们为每一个请求都单独创建一个线程，那么物理机的所有资源基本上都被操作系统创建线程、切换线程状态、销毁线程这些操作所占用，用于业务请求处理的资源反而减少了。所以最理想的处理方式是，将处理请求的线程数量控制在一个范围，既保证后续的请求不会等待太长时间，又保证物理机将足够的资源用于请求处理本身。另外，一些操作系统是有最大线程数量限制的。当运行的线程数量逼近这个值的时候，操作系统会变得不稳定。这也是我们要限制线程数量的原因。

我们先回顾之前的创建线程new Thread()：

new Thread(new Runnable(){
    @Override
    public void run(){
        //做事情
    }
}).start();

这样创建线程太out了，每次new Thread新建对象性能差。线程缺乏统一管理，可能五无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。缺乏更多功能，如定时执行、定期执行、线程中断。

相比于new Thread()，java提供的四种线程池的好处在于：重用存在的线程，减少对象的创建、消亡的开销，性能佳。

Executor框架：是一种将线程的创建和执行分离的机制。它基于Executor和ExecutorService接口，及这两个接口的实现类ThreadPoolExecutor展开，Executor有一个内部线程池，并提供了将任务传递到池中线程以获得执行的方法，可传递的任务有如下两种：通过Runnable接口实现的任务和通过Callable接口实现的任务。在这两种情况下，只需要传递任务到执行器，执行器即可使用线程池中的线程或新创建的线程来执行任务。执行器也决定了任务执行时间。而线程池就是基于此框架来实现的。

这篇博客先大概介绍线程池的核心AIP中的一些接口（先理清大概有什么，有个印象，实用通过后面的例子来仔细体会）

一、核心API介绍：

1、Executor接口

所有已知子接口：ExecutorService, ScheduledExecutorService

所有已知实现类：AbstractExecutorService, ScheduledThreadPoolExecutor, ThreadPoolExecutor

该接口声明了execute方法，将runnable对象传入，启动该方法相当于启动了该线程。

 Executor executor = anExecutor;
 executor.execute(new RunnableTask1());
 executor.execute(new RunnableTask2());
 ...

Executor接口中唯一方法：

void execute(Runnable command);
//在未来某个时间执行给定的命令。该命令可能在新的线程、已入池的线程或者正调用的线程中执行，这由 Executor 实现决定。

2、ExecutorService接口

所有超级接口： Executor

所有已知子接口：ScheduledExecutorService

所有已知实现类：AbstractExecutorService, ScheduledThreadPoolExecutor, ThreadPoolExecutor

该接口是Executor的子接口，提供了submit()方法，该方法返回Future对象，Future可用于控制线程的执行与取消；也提供了showdownNow()方法，对执行任务的终止，及返回列表等。

ExecutorService中的方法：

List<Runnable>shutdownNow();
//试图停止所有正在执行的活动任务，暂停处理正在等待的任务，并返回等待执行的任务列表。

void shutdown();
//启动一次顺序关闭，执行以前提交的任务，但不接受新任务。如果已经关闭，则调用没有其他作用。

<T> Future<T> submit(Callable<T> task);
//提交一个返回值的任务用于执行，返回一个表示任务的未决结果的 Future。该 Future 的 get 方法在成功完成时将会返回该任务的结果。
 
Future<?> submit(Runnable task);
// 提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future。

注：Callable 接口类似于 Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果，并且无法抛出经过检查的异常

3、ScheduleExecutorService接口

所有超级接口：Executor, ExecutorService

所有已知实现类：ScheduledThreadPoolExecutor

该接口是ExecutorService的子接口，提供了线程的启动时机的控制

ScheduleExecutorService中的方法

<V> ScheduleFuture<V> schedule(Callable<V> callable,long delay,TimeUnit unit)
//创建并执行在给定延迟后启用的 ScheduledFuture

ScheduleFuture<?> schedule(Runnable command,long delay,TimeUnit unit)
//创建并执行在给定延迟后启用的一次性操作

4、Callable接口

所有已知子接口：JavaCompiler.CompilationTask

该接口类似于Runnable接口，只是有返回值和抛出的异常。

Callable中的方法

V call()
//计算结果，如果无法计算结果，则抛出一个异常。该方法返回的计算值就是ExecutorService接口调用submit(Callable call)方法的Future调用get方法返回的值。

5、Future接口

所有已知子接口：Response<T>, RunnableFuture<V>, RunnableScheduledFuture<V>, ScheduledFuture<V>

所有已知实现类：FutureTask, SwingWorker

Future接口用于控制线程的执行

boolean cancel(boolean mayInterruptIfRunning) 
/*试图取消对此任务的执行。如果任务已完成、或已取消，或者由于某些其他原因而无法取消，
则此尝试将失败。当调用 cancel 时，如果调用成功，而此任务尚未启动，则此任务将永不运行。
如果任务已经启动，则 mayInterruptIfRunning 参数确定是否应该以试图停止任务的方式来中断执行此任务的线程。 
此方法返回后，对 isDone() 的后续调用将始终返回 true。
如果此方法返回 true，则isCancelled() 的后续调用将始终返回 true。*/

V get() 
//如有必要，等待计算完成，然后获取其结果。
 
//boolean isDone() 
//如果任务已完成，则返回 true。
 
boolean isCancelled()
//如果在任务正常完成前将其取消，则返回 true。

6、Executors类

这是一个线程池的工厂类，该类提供了许多生成Executor、ExecutorService、ThreadFactory、Callable类的一些使用的方法

创建并返回设置有常用配置字符串的 ExecutorService 的方法。
创建并返回设置有常用配置字符串的 ScheduledExecutorService 的方法。
创建并返回“包装的”ExecutorService 方法，它通过使特定于实现的方法不可访问来禁用重新配置。
创建并返回 ThreadFactory 的方法，它可将新创建的线程设置为已知的状态。
创建并返回非闭包形式的 Callable 的方法，这样可将其用于需要 Callable 的执行方法中

Executors中主要的方法：

方法①：newFixedThreadPool

public static ExecutorService newFixedThreadPool(int nThreads)
//参数：nThreads - 池中的线程数 
//返回值：新创建的线程池

创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。在任意点，在大多数 nThreads 线程会处于处理任务的活动状态。如果在所有线程处于活动状态时提交附加任务，则在有可用线程之前，附加任务将在队列中等待。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。在某个线程被显式地关闭之前，池中的线程将一直存在。

public static ExecutorService newFixedThreadPool(int nThreads,ThreadFactory threadFactory)
//参数：nThreads - 池中的线程数
//threadFactory - 创建新线程时使用的工厂 
//返回：新创建的线程池

创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程，在需要时使用提供的 ThreadFactory 创建新线程。在任意点，在大多数 nThreads 线程会处于处理任务的活动状态。如果在所有线程处于活动状态时提交附加任务，则在有可用线程之前，附加任务将在队列中等待。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。在某个线程被显式地关闭之前，池中的线程将一直存在。

方法②newSingleThreadExecutor

public static ExecutorService newSingleThreadExecutor()
//返回：新创建的单线程 Executor

创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。对于执行很多短期异步任务的程序而言，这些线程池通常可提高程序性能。调用 execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。因此，长时间保持空闲的线程池不会使用任何资源。注意，可以使用 ThreadPoolExecutor 构造方法创建具有类似属性但细节不同（例如超时参数）的线程池。

public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory)
//参数：threadFactory - 创建新线程时使用的工厂 
//返回：新创建的单线程 Executor

创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

方法③newCachedThreadPool

public static ExecutorService newCachedThreadPool()
//返回：新创建的线程池

public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory)
//参数：threadFactory - 创建新线程时使用的工厂 
返回：新创建的线程池

创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。

方法④newScheduledThreadPool

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
//参数：corePoolSize - 池中所保存的线程数，即使线程是空闲的也包括在内。 
//返回：新创建的安排线程池

创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize,ThreadFactory threadFactory)
//参数：corePoolSize - 池中所保存的线程数，即使线程是空闲的也包括在内
//threadFactory - 执行程序创建新线程时使用的工厂 
//返回：新创建的安排线程池

创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

接下来来创建各种的线程池：

①、固定大小的线程池，newFixedThreadPool：

public class MyThread extends Thread{
	@Override
	public void run(){
		System.out.println(Thread.currentThread().getName()+"正在执行。。。");
	}
}

public class Test_newFixedThreadPool {
	public static void main(String[] args) { 
	    // 创建一个可重用固定线程数的线程池 
	    ExecutorService pool = Executors.newFixedThreadPool(2); 
	    // 创建线程 
	    Thread t1 = new MyThread(); 
	    Thread t2 = new MyThread(); 
	    Thread t3 = new MyThread(); 
	    Thread t4 = new MyThread(); 
	    Thread t5 = new MyThread(); 
	    // 将线程放入池中进行执行 
	    pool.execute(t1); 
	    pool.execute(t2); 
	    pool.execute(t3); 
	    pool.execute(t4); 
	    pool.execute(t5); 
	    // 关闭线程池 
	    pool.shutdown(); 
	  } 
}

输出结果：

pool-1-thread-1正在执行。。。 
pool-1-thread-3正在执行。。。 
pool-1-thread-4正在执行。。。 
pool-1-thread-2正在执行。。。 
pool-1-thread-5正在执行。。。

改变ExecutorService pool = Executors.newFixedThreadPool(5)中的参数：ExecutorService pool = Executors.newFixedThreadPool(2)，输出结果是：

pool-1-thread-1正在执行。。。 
pool-1-thread-1正在执行。。。 
pool-1-thread-2正在执行。。。 
pool-1-thread-1正在执行。。。 
pool-1-thread-2正在执行。。。

从以上结果可以看出，newFixedThreadPool的参数指定了可以运行的线程的最大数目，超过这个数目的线程加进去以后，不会运行。其次，加入线程池的线程属于托管状态，线程的运行不受加入顺序的影响。

②、单任务线程池，newSingleThreadExecutor：

仅仅是把上述代码中的ExecutorService pool = Executors.newFixedThreadPool(2)改为ExecutorService pool = Executors.newSingleThreadExecutor();

输出结果是：

pool-1-thread-1正在执行。。。 
pool-1-thread-1正在执行。。。 
pool-1-thread-1正在执行。。。 
pool-1-thread-1正在执行。。。 
pool-1-thread-1正在执行。。。

可以看出，每次调用execute方法，其实最后都是调用了thread-1的run方法。

③、可变尺寸的线程池，newCachedThreadPool：

与上面的类似，只是改动下pool的创建方式：ExecutorService pool = Executors.newCachedThreadPool();

输出结果：

pool-1-thread-1正在执行。。。 
pool-1-thread-2正在执行。。。 
pool-1-thread-4正在执行。。。 
pool-1-thread-3正在执行。。。 
pool-1-thread-5正在执行。。。

④、延迟连接池，newScheduledThreadPool：

这种方式的特点是：可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。

public class TestScheduledThreadPoolExecutor {
 
  public static void main(String[] args) {
 
    ScheduledThreadPoolExecutor exec = new ScheduledThreadPoolExecutor(1);
 
    exec.scheduleAtFixedRate(new Runnable() {//每隔一段时间就触发异常
 
           @Override
 
           publicvoid run() {
 
              //throw new RuntimeException();
 
              System.out.println("================");
 
           }
 
         }, 1000, 5000, TimeUnit.MILLISECONDS);
 
    exec.scheduleAtFixedRate(new Runnable() {//每隔一段时间打印系统时间，证明两者是互不影响的
 
           @Override
 
           publicvoid run() {
 
              System.out.println(System.nanoTime());
 
           }
 
         }, 1000, 2000, TimeUnit.MILLISECONDS);
 
  }
 
}

================
 
8384644549516
 
8386643829034
 
8388643830710
 
================
 
8390643851383
 
8392643879319
 
8400643939383

7、ScheduledThreadPoolExecutor类

所有已实现的接口：Executor, ExecutorService, ScheduledExecutorService

ScheduledThreadPoolExecutor中的构造方法：

public ScheduledThreadPoolExecutor(int corePoolSize)
//使用给定核心池大小创建一个新 ScheduledThreadPoolExecutor。 
//参数：corePoolSize - 池中所保存的线程数（包括空闲线程） 

public ScheduledThreadPoolExecutor(int corePoolSize,ThreadFactory threadFactory)
//使用给定的初始参数创建一个新 ScheduledThreadPoolExecutor。 
//参数：corePoolSize - 池中所保存的线程数（包括空闲线程）threadFactory - 执行程序创建新线程时使用的工厂 

public ScheduledThreadPoolExecutor(int corePoolSize, RejectedExecutionHandler handler)
//使用给定初始参数创建一个新 ScheduledThreadPoolExecutor。 
//参数：corePoolSize - 池中所保存的线程数（包括空闲线程）
handler - 由于超出线程范围和队列容量而使执行被阻塞时所使用的处理程序 

public ScheduledThreadPoolExecutor(int corePoolSize,ThreadFactory threadFactory,RejectedExecutionHandler handler)
//使用给定初始参数创建一个新 ScheduledThreadPoolExecutor。 
//参数：corePoolSize - 池中所保存的线程数（包括空闲线程）threadFactory - 执行程序创建新线程时使用的工厂
//handler - 由于超出线程范围和队列容量而使执行被阻塞时所使用的处理程序

ScheduledThreadPoolExecutor的方法：

public ScheduledFuture<?> schedule(Runnable command,long delay,TimeUnit unit)
//创建并执行在给定延迟后启用的一次性操作。 
//参数：command - 要执行的任务  delay - 从现在开始延迟执行的时间  unit - 延迟参数的时间单位 

public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay,TimeUnit unit)
//创建并执行在给定延迟后启用的 ScheduledFuture。 
//参数：callable - 要执行的功能  delay - 从现在开始延迟执行的时间  unit - 延迟参数的时间单位 

public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,long initialDelay,long period,TimeUnit unit)
//创建并执行一个在给定初始延迟后首次启用的定期操作，后续操作具有给定的周期；也就是将在 initialDelay 后开始执行，然后在 initialDelay+period 后执行，接着在 initialDelay + 2 * period 后执行，依此类推。如果任务的任何一个执行遇到异常，则后续执行都会被取消。否则，只能通过执行程序的取消或终止方法来终止该任务。如果此任务的任何一个执行要花费比其周期更长的时间，则将推迟后续执行，但不会同时执行。 
//参数：command - 要执行的任务  initialDelay - 首次执行的延迟时间  period - 连续执行之间的周期
  unit - initialDelay 和 period 参数的时间单位 

public List<Runnable> shutdownNow()
//尝试停止所有正在执行的任务、暂停等待任务的处理，并返回等待执行的任务列表。虽然尽最大努力，但并不保证可以停止处理正在执行的任务。此实现通过 Thread.interrupt() 取消任务,所以任何无法响应中断的任务都可能永远无法终止。 

public void shutdown()
//在以前已提交任务的执行中发起一个有序的关闭，但是不接受新任务。如果已将ExecuteExistingDelayedTasksAfterShutdownPolicy 设置为 false，则取消尚未超出其延迟的现有延迟任务。并且除非已将 ContinueExistingPeriodicTasksAfterShutdownPolicy 设置为 true，否则将取消现有定期任务的后续执行。

以上是线程池部分的方法及类.

一般使用Executors工厂来创建线程池

通过这几种方式来创建线程池：

newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

_SpringBoot

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
线程池

线程池：线程池是指一个在初始化一个多线程应用程序过程中创建一个线程集合，然后在需要执行新的任务时重用这些线程而不是新建一个线程。线程池中线程的数量通常完全取决于可用内存数量和应用程序的需求。然而，增加可用线程数量是有限的。线程池中的每个线程都有被分配一个任务，一旦任务已经完成了。线程回到池子中并等待一下一次分配任务。为什么要创建线程池：由操作系统来创建线程、切换线程状态、终结线程都要进行CPU...
复制链接

扫一扫