java——线程池

已于 2022-08-04 09:03:58 修改
阅读量1.4w 收藏 33
点赞数 16
分类专栏： java基础 文章标签： java 开发语言 后端
于 2021-12-10 10:37:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Pluto372/article/details/121850641
版权

一、线程池

线程池可以看做是线程的集合。它的工作主要是控制运行的线程的数量，处理过程中将任务放入队列，然后在线程创建后 启动这些任务，如果线程数量超过了最大数量超出数量的线程排队等候，等其它线程执行完毕， 再从队列中取出任务来执行。他的主要特点为：线程复用；控制最大并发数；管理线程。
​

线程复用：

每一个 Thread 的类都有一个 start 方法。 当调用 start 启动线程时 Java 虚拟机会调用该类的 run 方法。 那么该类的 run() 方法中就是调用了 Runnable 对象的 run() 方法。 我们可以继承重写 Thread 类，在其 start 方法中添加不断循环调用传递过来的 Runnable 对象。 这就是线程池的实 现原理。循环方法中不断获取 Runnable 是用 Queue 实现的，在获取下一个 Runnable 之前可以 是阻塞的。
​

一般的线程池主要分为以下 4 个组成部分：

  1. 线程池管理器：用于创建并管理线程池
  2. 工作线程：线程池中的线程
  3. 任务接口：每个任务必须实现的接口，用于工作线程调度其运行
  4. 任务队列：用于存放待处理的任务，提供一种缓冲机制

Java 中的线程池是通过 Executor 框架实现的，该框架中用到了 Executor，Executors， ExecutorService，ThreadPoolExecutor ，Callable 和 Future、FutureTask 这几个类。
​

线程池工作过程 ：

  1. 线程池刚创建时，里面没有一个线程。任务队列是作为参数传进来的。不过，就算队列里面
    有任务，线程池也不会马上执行它们。
  2. 当调用 execute() 方法添加一个任务时，线程池会做如下判断：
    a) 如果正在运行的线程数量小于 corePoolSize，那么马上创建线程运行这个任务；
    b) 如果正在运行的线程数量大于或等于 corePoolSize，那么将这个任务放入队列；
    c) 如果这时候队列满了，而且正在运行的线程数量小于 maximumPoolSize，那么还是要
    创建非核心线程立刻运行这个任务；
    d) 如果队列满了，而且正在运行的线程数量大于或等于 maximumPoolSize，那么线程池
    会抛出异常 RejectExecutionException。
  3. 当一个线程完成任务时，它会从队列中取下一个任务来执行。
  4. 当一个线程无事可做，超过一定的时间（keepAliveTime）时，线程池会判断，如果当前运
    行的线程数大于 corePoolSize，那么这个线程就被停掉。所以线程池的所有任务完成后，它
    最终会收缩到 corePoolSize 的大小。

创建和销毁线程所花费的时间和资源可能比处理任务所花费的时间和资源还要多，所以说：我们的线程最好是交由线程池来管理，这样可以减少对线程生命周期的管理，一定程度上提高性能。

二、JDK提供的线程池API

DK给我们提供了Excutor框架来使用线程池，它是线程池的基础。

  • Executor提供了一种将**“任务提交”与“任务执行”**分离开来的机制(解耦)

在这里插入图片描述

Executor接口：

public interface Executor {

    /**
     * 执行任务
     */
    void execute(Runnable command);
}

ExcutorService接口：

public interface ExecutorService extends Executor {

    /**
     * 关闭线程池
     */
    void shutdown();

    /**
     * 停止所有主动执行的任务以及停止等待任务的处理，并返回任务列表
     */
    List<Runnable> shutdownNow();

    /**
     * 是否关闭线程池
     */
    boolean isShutdown();

    /**
     * 判断是否所有任务在关闭后全部完成
     */
    boolean isTerminated();

    /**
     * 判断任务执行超时还是提前终止
     * 超时:true
     * 提前终止:false
     */
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;

    /**
     * 提交任务用于执行
     */
    <T> Future<T> submit(Callable<T> task);

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

    Future<?> submit(Runnable task);

    /**
     * 执行给定的任务
     */
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;

    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                  long timeout, TimeUnit unit)
        throws InterruptedException;

    <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;

    <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

AbstractExecutorService类：

对于ExecutorService接口的默认实现，同时新增了三个方法。

public abstract class AbstractExecutorService implements ExecutorService {

   
    protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
        return new FutureTask<T>(runnable, value);
    }
    protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
        return new FutureTask<T>(callable);
    }
    private <T> T doInvokeAny(Collection<? extends Callable<T>> tasks,
                              boolean timed, long nanos)
        throws InterruptedException, ExecutionException, TimeoutException {
        if (tasks == null)
            throw new NullPointerException();
        int ntasks = tasks.size();
        if (ntasks == 0)
            throw new IllegalArgumentException();
        ArrayList<Future<T>> futures = new ArrayList<Future<T>>(ntasks);
        ExecutorCompletionService<T> ecs =
            new ExecutorCompletionService<T>(this);

        // For efficiency, especially in executors with limited
        // parallelism, check to see if previously submitted tasks are
        // done before submitting more of them. This interleaving
        // plus the exception mechanics account for messiness of main
        // loop.

        try {
            // Record exceptions so that if we fail to obtain any
            // result, we can throw the last exception we got.
            ExecutionException ee = null;
            final long deadline = timed ? System.nanoTime() + nanos : 0L;
            Iterator<? extends Callable<T>> it = tasks.iterator();

            // Start one task for sure; the rest incrementally
            futures.add(ecs.submit(it.next()));
            --ntasks;
            int active = 1;

            for (;;) {
                Future<T> f = ecs.poll();
                if (f == null) {
                    if (ntasks > 0) {
                        --ntasks;
                        futures.add(ecs.submit(it.next()));
                        ++active;
                    }
                    else if (active == 0)
                        break;
                    else if (timed) {
                        f = ecs.poll(nanos, TimeUnit.NANOSECONDS);
                        if (f == null)
                            throw new TimeoutException();
                        nanos = deadline - System.nanoTime();
                    }
                    else
                        f = ecs.take();
                }
                if (f != null) {
                    --active;
                    try {
                        return f.get();
                    } catch (ExecutionException eex) {
                        ee = eex;
                    } catch (RuntimeException rex) {
                        ee = new ExecutionException(rex);
                    }
                }
            }

            if (ee == null)
                ee = new ExecutionException();
            throw ee;

        } finally {
            for (int i = 0, size = futures.size(); i < size; i++)
                futures.get(i).cancel(true);
        }
    }
    ......
}

ScheduledExecutorService接口：

在这里插入图片描述

​

ThreadPoolExecutor类：

这个类是我们用的最多的类，要重点掌握！！！
在这里插入图片描述

ScheduledThreadPoolExecutor类：

相当于提供了“延迟”和“周期性”执行功能的ThreadPoolExecutor类
在这里插入图片描述

2.1 Callable和Future

我们都知道创建线程的两种方式，一是继承Thread类，重写run方法、二是实现Runable接口，重写run方法。

public class TestThread extends Thread{
    @Override
    public void run() {
       
    }
}

----------------
  
public class TestThread implements Runnable{
    
    @Override
    public void run() {
        
    }
}

可以看到run()方法是没有返回值的。那我们想要执行多线程任务后返回给我们任务的结果怎么办?
让我们看看第三种创建线程的方式：实现Callabl接口。重写call方法。
通过上边线程池的简单了解，我们发现：很多的API都有Callable和Future这么两个东西。

Future<?> submit(Runnable task)
<T> Future<T> submit(Callable<T> task)

简单看一下Callable接口，这是个函数式接口，里面只有一个call方法，注释很简单：计算结果，如果无法计算则抛出异常。return的是计算的结果。
在这里插入图片描述

当我们的任务需要返回值的时，我们就可以使用Callable！Future和Callable通常是一起使用的，
它一般我们认为是Callable的返回值，但他其实代表的是任务的生命周期(它是能获取得到Callable的返回值的)。我们看下Future接口的源码：

public interface Future<V> {

    /**
     * 用于停止任务。如果尚未启动，它将停止任务。如果已启动，则仅在mayInterrupt为true时才会中断任务。
     */
    boolean cancel(boolean mayInterruptIfRunning);

    /**
     * 判断任务是否被取消
     * 如果此任务在完成之前已取消则为true
     */
    boolean isCancelled();

    /**
     * 如果任务完成，则返回true，否则返回false
     */
    boolean isDone();

    /**
     * 用于获取任务的结果。如果任务完成，它将立即返回结果，否则将等待任务完成，然后返回结果。
     */
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

Future和Callable示例：

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        
        FutureTask<Integer> future = new FutureTask<>(new CallableDemo(100));

        Thread thread = new Thread(future);
        thread.start();

        //获取任务执行返回值
        Integer result = future.get();

        System.out.println(result);
    }
}
class CallableDemo implements Callable<Integer>{

    private int number;

    public CallableDemo(int number) {
        this.number = number;
    }

    @Override
    public Integer call() {
        int sum = 0;
        for (int x = 1; x <= number; x++) {
            sum += x;
        }
        return sum;
    }
}


console: 5050

FutureTask实现了RunnableFuture接口，而RunnableFuture继承了Runnable和Future，也就是说FutureTask既是Runnable，也是Future。
​

三、ThreadPoolExecutor详解

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： 是指线程池中的线程数量，它的数量决定了添加的任务是开辟新的线程去执行，还是放到workQueue任务队列中去，简单理解就是corePoolSize表示允许线程池中允许同时运行的最大线程数；
  • maximumPoolSize： 线程池中最大线程数量**，**这个参数会根据你使用的workQueue任务队列的类型，决定线程池会开辟的最大线程数量；maximumPoolSize肯定是大于等于corePoolSize
  • keepAliveTime： 当线程池中空闲线程数量超过corePoolSize时，多余的线程会在多长时间内被销毁；
  • unit： keepAliveTime的单位；
  • workQueue： 任务队列，被添加到线程池中，但尚未被执行的任务；它一般分为直接提交队列、有界任务队列、无界任务队列、优先任务队列几种；
  • threadFactory： 线程工厂，用于创建线程，一般用默认即可；
  • handler： 任务拒绝策略，当任务太多来不及处理时，如何拒绝任务；

线程数量要点：

  • 如果运行线程的数量少于核心线程数量，则创建新的线程处理请求
  • 如果运行线程的数量大于核心线程数量，小于最大线程数量，则当队列满的时候才创建新的线程
  • 如果核心线程数量等于最大线程数量，那么将创建固定大小的连接池
  • 如果设置了最大线程数量为无穷，那么允许线程池适合任意的并发数量

线程空闲时间要点：

  • 当前线程数大于核心线程数，如果空闲时间已经超过了，那该线程会销毁。

排队策略要点：

  • 同步移交：不会放到队列中，而是等待线程执行它。如果当前线程没有执行，很可能会新开一个线程执行。
  • 无界限策略：如果核心线程都在工作，该线程会放到队列中。所以线程数不会超过核心线程数
  • 有界限策略：可以避免资源耗尽，但是一定程度上减低了吞吐量

当线程关闭或者线程数量满了和队列饱和了，就有拒绝任务的情况了：
拒绝任务策略：

  • 直接抛出异常
  • 使用调用者的线程来处理
  • 直接丢掉这个任务
  • 丢掉最老的任务

3.1 workQueue任务队列

workQueue任务队列一般分为直接提交队列、有界任务队列、无界任务队列、优先任务队列；
1、直接提交队列synchronousQueue： 这个队列比较特殊，它不会保存提交的任务，而是将直接新建一个线程来执行新来的任务
2、有界任务队列ArrayBlockingQueue： 基于数组的先进先出队列，此队列创建时必须指定大小；
3、无界任务队列LinkedBlockingQueue： 基于链表的先进先出队列，如果创建时没有指定此队列大小，则默认为Integer.MAX_VALUE；
4、优先任务队列PriorityBlockingQueue： 优先任务队列通过PriorityBlockingQueue实现

直接提交队列示例：

public class ThreadPoolTest {  
  private static  ExecutorService pool;   
  public static void main(String[] args) {        
 	 pool = new ThreadPoolExecutor(1, 2, 1000, TimeUnit.MILLISECONDS,new SynchronousQueue<Runnable>(), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());        
	  for (int i = 0; i < 3; i++) {        
    	  pool.execute(new ThreadDemo());      
        }  
     }
  }
class ThreadDemo implements Runnable{    
      @Override   
       public void run() {   
            System.out.println(Thread.currentThread().getName());    
      }
}

Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task com.zsn.scheduler.Thread.ThreadDemo@1be6f5c3 rejected from java.util.concurrent.ThreadPoolExecutor@6b884d57[Running, pool size = 2, active threads = 2, queued tasks = 0, completed tasks = 0]	at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2063)	at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:830)	at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1379)	at com.zsn.scheduler.Thread.ThreadPoolTest.main(ThreadPoolTest.java:20)pool-1-thread-1pool-1-thread-2

使用SynchronousQueue队列，提交的任务不会被保存，总是会马上提交执行。如果用于执行任务的线程数量小于maximumPoolSize，则尝试创建新的进程，如果达到maximumPoolSize设置的最大值，则根据你设置的handler执行拒绝策略
​

有界任务队列示例：

pool = new ThreadPoolExecutor(1, 2, 1000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());

使用ArrayBlockingQueue有界任务队列，若有新的任务需要执行时，线程池会创建新的线程，直到创建的线程数量达到corePoolSize时，则会将新的任务加入到等待队列中。若等待队列已满，即超过ArrayBlockingQueue初始化的容量，则继续创建线程，直到线程数量达到maximumPoolSize设置的最大线程数量，若大于maximumPoolSize，则执行拒绝策略。
无界任务队列示例：

pool = new ThreadPoolExecutor(1, 2, 1000, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());

使用无界任务队列，线程池的任务队列可以无限制的添加新的任务，而线程池创建的最大线程数量就是你corePoolSize设置的数量，也就是说在这种情况下maximumPoolSize这个参数是无效的，哪怕你的任务队列中缓存了很多未执行的任务，当线程池的线程数达到corePoolSize后，就不会再增加了；若后续有新的任务加入，则直接进入队列等待，当使用这种任务队列模式时，一定要注意你任务提交与处理之间的协调与控制，不然会出现队列中的任务由于无法及时处理导致一直增长，直到最后资源耗尽的问题。
​

优先任务队列PriorityBlockingQueue：
PriorityBlockingQueue它其实是一个特殊的无界队列，它其中无论添加了多少个任务，线程池创建的线程数也不会超过corePoolSize的数量，只不过其他队列一般是按照先进先出的规则处理任务，而PriorityBlockingQueue队列可以自定义规则根据任务的优先级顺序先后执行。

3.2 拒绝策略

线程池中的线程已经用完了，无法继续为新任务服务，同时，等待队列也已经排满了，再也
塞不下新任务了。这时候我们就需要拒绝策略机制合理的处理这个问题。
JDK 内置的拒绝策略如下：

  1. AbortPolicy ： 直接抛出异常，阻止系统正常运行。
  2. CallerRunsPolicy ： 只要线程池未关闭，该策略直接在调用者线程中，运行当前被丢弃的
    任务。显然这样做不会真的丢弃任务，但是，任务提交线程的性能极有可能会急剧下降。
  3. DiscardOldestPolicy ： 丢弃最老的一个请求，也就是即将被执行的一个任务，并尝试再
    次提交当前任务。
  4. DiscardPolicy ： 该策略默默地丢弃无法处理的任务，不予任何处理。如果允许任务丢
    失，这是最好的一种方案。
    以上内置拒绝策略均实现了 RejectedExecutionHandler 接口，若以上策略仍无法满足实际
    需要，完全可以自己扩展 RejectedExecutionHandler 接口。

3.3 已默认实现的池

下面我就列举三个比较常见的实现池：

  • newFixedThreadPool
  • newCachedThreadPool
  • SingleThreadExecutor
newFixedThreadPool

newFixedThreadPool是一个固定线程数的线程池，它将返回一个corePoolSize和maximumPoolSize相等的线程池。

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

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

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

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

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory) {        
 return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);    
 }

 ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3); 
 	scheduledThreadPool.schedule(newRunnable(){         
 	@Override         
 	public void run() {         
 		System.out.println("延迟三秒");         
 		} 	
 	}, 3, TimeUnit.SECONDS);	
 	scheduledThreadPool.scheduleAtFixedRate(newRunnable(){ 		
 	@Override 		
 	public void run() { 		
 	System.out.println("延迟 1 秒后每三秒执行一次"); 		
 		} 	
 	},1,3,TimeUnit.SECONDS);
newSingleThreadExecutor

Executors.newSingleThreadExecutor()返回一个线程池（这个线程池只有一个线程）,这个线程池可以在线程死后（或发生异常时）重新启动一个线程来替代原来的线程继续执行下去！

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

四、execute执行方法

public void execute(Runnable command) {        
	if (command == null) throw new NullPointerException();        
	int c = ctl.get();		
	//如果线程池中运行的线程数量<corePoolSize，则创建新线程来处理请求，即使其他辅助线程是空闲的。        
	if (workerCountOf(c) < corePoolSize) {            
		if (addWorker(command, true)) return;            
		c = ctl.get();        
	}		
	//如果线程池中运行的线程数量>=corePoolSize，且线程池处于RUNNING状态，且把提交的任务成功放入阻塞队列中，就再次检查线程池的状态，			
	// 1.如果线程池不是RUNNING状态，且成功从阻塞队列中删除任务，则该任务由当前 RejectedExecutionHandler 处理。			
	// 2.否则如果线程池中运行的线程数量为0，则通过addWorker(null, false)尝试新建一个线程，新建线程对应的任务为null。        
	if (isRunning(c) && workQueue.offer(command)) {            
		int recheck = ctl.get();            
		if (! isRunning(recheck) && remove(command)) reject(command);           
		else if (workerCountOf(recheck) == 0) addWorker(null, false);        
	   }		
		// 如果以上两种case不成立，即没能将任务成功放入阻塞队列中，且addWoker新建线程失败，则该任务由当前 RejectedExecutionHandler 处理。        
		else if (!addWorker(command, false))reject(command);
		}

五、线程池关闭

ThreadPoolExecutor提供了shutdown()和shutdownNow()两个方法来关闭线程池

  • 调用shutdown()后，线程池状态立刻变为SHUTDOWN，而调用shutdownNow()，线程池状态立刻变为STOP。
  • shutdown()等待任务执行完才中断线程，而shutdownNow()不等任务执行完就中断了线程。
Pluto372
关注
专栏目录
Java——线程池(一）
weixin_47163086的博客
10-14 2375
1、为什么要使用线程池？ 例如：当前我们有一个任务，任务内容为输出当前线程的名称，然后我们创建一个该任务，创建一个线程，将该任务交给该线程，然后启动线程。 public class Task implements Runnable{ @Override public void run() { //输出当前线程的名称 System.out.println(Thread.currentThread().getName()); } } public cla
Java 线程池
05-01
NULL 博文链接：https://yangeoo.iteye.com/blog/2249853
Java线程池总结
走在风雨路的专栏
06-21 405
假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。当T1 + T3 远大于 T2时，采用多线程技术可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。     线程池就是一个线程的容器，每次只执行额定数量的线程， 线程池作用就是限制系统中执行线程的数量。采用线程池不仅调整T1,T3产生的时间段，而且它还显著减少了创建线程的数目。
Java线程池
最新发布
qq_52659547的博客
10-02 1024
1、线程池的优点 2、线程池核心参数 3、线程池的工作流程？ 4、线程池的使用 5、常见线程池
Java Thread 多线程 线程池
hoojo
05-05 1562
线程池 线程相关类、集合 16、线程池 Why? 系统启动一个新线程的成本比较高，因为涉及到与操作系统交互。这个时候用线程池可以很好的提高性能， 尤其是当程序中需要创建大量生存期很短暂的线程时，更应该考虑使用线程池。 原理：（流程）线程池和数据库连接池有点类似的是，线程池在系统启动时创建大量空闲线程，程序将一个Runnable对象传给线程池， 线程池就会启动一条线程来执行该
Java中的线程池
热门推荐
李江东
04-28 1万+
在我们的开发中经常会使用到多线程。例如在Android中，由于主线程的诸多限制，像网络请求等一些耗时的操作我们必须在子线程中运行。我们往往会通过new Thread来开启一个子线程，待子线程操作完成以后通过Handler切换到主线程中运行。这么以来我们无法管理我们所创建的子线程，并且无限制的创建子线程，它们相互之间竞争，很有可能由于占用过多资源而导致死机或者OOM。
java的线程池
qq_51476492的博客
06-16 614
例如，自定义一个线程池，核心线程有3个，临时线程有3个，阻塞队列长度为3。当有8个任务提交时，线程池现创建3个线程执行前3个任务，第4，5，6个任务阻塞队列中排队等待，线程池再创建2个临时线程取处理任务7和任务8。当有10个任务提交时，线程池现创建3个线程执行前3个任务，第4，5，6个任务阻塞队列中排队等待，线程池再创建3个临时线程取处理任务7、8、9，任务10会触发任务拒绝策略。核心线程数量，线程池中最大线程数量、空闲时间（值）、空闲时间（单位）、阻塞队列、创建线程的方式、要执行的任务过多时的解决方案。
十二、连接池线程池配置——线程池
流楚丶格念的博客
08-27 1101
如果需要在 Spring Boot 中创建自定义线程池（例如用于特定的任务或服务），可以使用。
Java面试题之——线程池
m0_74823507的博客
10-11 206
再着一个服务中会运行着很多线程，比如 Tomcat 有自己的线程池、Dubbo 有自己的线程池、GC 也有自己的后台线程，我们引入的各种框架、中间件都有可能有自己的工作线程，这些线程都会占用 CPU 资源，所以通过此公式计算出来的误差一定很大。作为 JUC 包下的门面担当，线程池是名副其实的 JUC 一哥，不了解线程池，那说明你对 JUC 包其他工具也了解的不咋样吧，对 JUC 没深入研究过，那就是没掌握到 Java 的精髓，给面试官这样一个印象，那结果可想而知了。
线程池——线程池创建的5种方法
qq_44891295的博客
04-13 1370
文章目录1 newFixedThreadPool 方法2 newSingleThreadExcutor方法3 newCachedThreadPool方法4 newSingleThreadScheduledExecutor方法5 newScheduledThreadPool方法 1 newFixedThreadPool 方法 newFixedThreadPool() 方法：该方法返回一个固定线程数量的线程池。该线程池中的线程数量始终不变。当有一个新的任务提交时，线程池中若有空闲线程，则立即执行。若没有，则新的
java:线程池
m0_74217856的博客
09-03 2335
答：线程池就是一个可以复用线程的技术。
Java 中的线程池
飞鱼的博客
08-19 466
本文主要介绍了线程池框架 Executor，ThreadPoolExecutor 的「构造参数」和「工作行为」，线程池的生命周期，Executors 提供的线程池
java中的线程池
diandiekang7035的博客
06-25 225
为什么要使用线程池在Java中，如果每当一个请求到达就创建一个新线程，开销是相当大的。在实际使用中，每个请求创建新线程的服务器在创建和销毁线程上花费的时间和消耗的系统资源，甚至可能要比花在处理实际的用户请求的时间和资源要多得多。除了创建和销毁线程的开销之外，活动的线程也需要消耗系统资源。如果在一个JVM里创建太多的线程，可能会导致系统由于过度消耗内存或“切换过度”而导致系统资源不足。为了...
java中线程池的创建_java中有几种创建线程池的方法
weixin_31225753的博客
02-16 216
java中有几种创建线程池的方法发布时间：2020-06-29 13:52:17来源：亿速云阅读：125作者：Leahjava中有几种创建线程池的方法？针对这个问题，这篇文章详细介绍了相对应的分析和解答，希望可以帮助更多想解决这个问题的小伙伴找到更简单易行的方法。线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆...
java 线程池 完成端口_I/O完成端口、异步I/O、APC和线程池（四）——线程池
05-13
Java线程池是一种用于管理和复用线程的机制，它可以帮助我们更好地管理线程，防止线程过多导致系统资源的浪费和性能问题。线程池通过一个池子来缓存和复用线程，让线程可以被重复利用，从而减少线程的创建和销毁的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值