请你谈谈对线程池的理解？

已于 2022-11-10 10:09:09 修改
阅读量1.1k 收藏 3
点赞数 1
文章标签： juc
于 2021-02-27 16:49:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zs18753479279/article/details/114177661
版权

1 线程池ThreadPool是什么？

线程过多会带来额外的开销，其中包括创建销毁线程的开销、调度线程的开销等等，同时也降低了计算机的整体性能。线程池维护多个线程，等待、监督、管理、分配可并发执行的任务。这种做法，一方面避免了处理任务时创建销毁线程开销的代价，另一方面避免了线程数量膨胀导致的过分调度问题，保证了对内核的充分利用。线程池是一种通过“池化”思想，帮助我们管理线程而获取并发性的工具，在Java中的体现是ThreadPoolExecutor类。

2 Executors [ɪgˈzɛkjətərz] 创建四种常见线程池

2.1 newFixedThreadPool

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

从构造方法可以看出，它创建了一个固定大小的线程池，每次提交一个任务就创建一个线程，直到线程数达到线程池的最大值nThreads。线程池的大小一旦达到最大值后，再有新的任务提交时则放入阻塞队列中，等到有线程空闲时，再从队列中取出任务继续执行。FixedThreadPool提高程序效率和节省创建线程时所耗的开销的优点。但是，在线程池空闲时，即线程池中没有可运行任务时，它不会释放工作线程，还会占用一定的系统资源。

package com.zs.thread;
public class TestVolatile {
    public static void main(String[] args) {
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);

        for (int i = 0; i < 5; i++) {
            final int index = i;
            fixedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
                        System.out.println("运行时间: " + sdf.format(new Date()) + " " + index);
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        fixedThreadPool.shutdown();
    }
}

例中创建了一个固定大小为3的线程池，然后在线程池提交了5个任务。在提交第4个任务时，因为线程池的大小已经达到了3并且前3个任务在运行中，所以第4个任务被放入了队列，等待有空闲的线程时再被运行。运行结果如下（注意前3个任务和后2个任务的运行时间）：
在这里插入图片描述

2.2 newCachedThreadPool

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

从构造方法可以看出，它创建了一个可缓存的线程池。当有新的任务提交时，有空闲线程则直接处理任务，没有空闲线程则创建新的线程处理任务，队列中不储存任务。线程池不对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。如果线程空闲时间超过了60秒就会被回收。在使用CachedThreadPool时，一定要注意控制任务的数量，否则，由于大量线程同时运行，很有会造成系统OOM。

package com.zs.thread;

public class TestVolatile {
    public static void main(String[] args) {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

        for (int i = 0; i < 5; i++) {
            final int index = i;
            cachedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        SimpleDateFormat sdf = new SimpleDateFormat(
                                "HH:mm:ss");
                        System.out.println("运行时间: " +
                                sdf.format(new Date()) + " " + index);
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }

        cachedThreadPool.shutdown();
    }
}

因为这种线程有新的任务提交，就会创建新的线程（线程池中没有空闲线程时），不需要等待，所以提交的5个任务的运行时间是一样的。
在这里插入图片描述

2.3 newSingleThreadExecutor

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

从构造方法可以看出，它创建了一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。如果这个线程异常结束，会有另一个取代它，保证顺序执行。单工作线程最大的特点是可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。

package com.zs.thread;

public class TestVolatile {
    public static void main(String[] args) {
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

        for (int i = 0; i < 5; i++) {
            final int index = i;
            singleThreadExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        SimpleDateFormat sdf = new SimpleDateFormat(
                                "HH:mm:ss");
                        System.out.println("运行时间: " +
                                sdf.format(new Date()) + " " + index);
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }

        singleThreadExecutor.shutdown();
    }
}

因为该线程池类似于单线程执行，所以先执行完前一个任务后，再顺序执行下一个任务：
在这里插入图片描述
既然类似于单线程执行，那么这种线程池还有存在的必要吗？这里的单线程执行指的是线程池内部，从线程池外的角度看，主线程在提交任务到线程池时并没有阻塞，仍然是异步的。

2.4 newScheduledThreadPool

这个方法创建了一个固定大小的线程池，支持定时及周期性任务执行。
首先看一下定时执行的例子：

package com.zs.thread;

public class TestVolatile {
    public static void main(String[] args) {
        final SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
        System.out.println("提交时间: " + sdf.format(new Date()));
        scheduledThreadPool.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("运行时间: " + sdf.format(new Date()));
            }
        }, 3, TimeUnit.SECONDS);
        scheduledThreadPool.shutdown();
    }
}

使用该线程池的schedule方法，延迟3秒钟后执行任务，运行结果如下：
在这里插入图片描述
再看一下周期执行的例子：

package com.zs.thread;

public class TestVolatile {
    public static void main(String[] args) throws InterruptedException {
        final SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
        System.out.println("提交时间: " + sdf.format(new Date()));
        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("运行时间: " + sdf.format(new Date()));
            }
        }, 1, 3, TimeUnit.SECONDS);
        Thread.sleep(10000);
        scheduledThreadPool.shutdown();
    }
}

使用该线程池的scheduleAtFixedRate方法，延迟1秒钟后每隔3秒执行一次任务，运行结果如下：
在这里插入图片描述

2. 5 Executors 各个方法的弊端：

方法弊端
FixedThreadPool && SingleThreadPool允许的请求队列长度为Integer.Max_value，可能会堆积大量请求,导致OOM
CachedThreadPool && ScheduledThreadPool允许的创建线程数量为Integer.Max_value，可能会创建大量线程，导致OOM

阿里巴巴的Java操作手册中明确说明：对于Integer.MAX_VALUE初始值较大，所以一般情况我们要使用底层的ThreadPoolExecutor来创建线程池。

3 生命周期管理，线程池都有哪些状态？

在这里插入图片描述

状态特点
RUNNING这是最正常的状态：接受新的任务，处理等待队列中的任务
SHUTDOWN不接受新的任务提交，但是会继续处理等待队列中的任务：在线程池处于 RUNNING 状态时，调用 shutdown 方法会使线程池进入到该状态。finalize 方法在执行过程中也会调用 shutdown 方法进入该状态。
STOP不接受新的任务提交，不再处理等待队列中的任务，中断正在执行任务的线程 ：在线程池处于 RUNNING 或 SHUTDOWN 状态时，调用 shutdownNow 方法会使线程池进入到该状态。
TIDYING如果所有的任务都已终止了，workerCount (有效线程数) 为 0，线程池进入该状态后会调用 terminated 方法进入 TERMINATED 状态。
TERMINATEDterminated()方法结束后，线程池的状态就会变成这个

任务调度

首先，所有任务的调度都是由execute方法完成的：（workerCount：前线程池的线程数，corePoolSize：基本大小线程数，maximumPoolSize：线程池中允许的最大线程数）

1 首先检测线程池运行状态，如果不是RUNNING，则直接拒绝，线程池要保证在RUNNING的状态下执行任务。

2 如果workerCount < corePoolSize，则创建并启动一个线程来执行新提交的任务。

3 如果workerCount >= corePoolSize，且线程池内的阻塞队列未满，则将任务添加到该阻塞队列中。

4 如果workerCount >= corePoolSize && workerCount < maximumPoolSize，且线程池内的阻塞队列已满，则创建并启动一个线程来执行新提交的任务。

5 如果workerCount >= maximumPoolSize，并且线程池内的阻塞队列已满, 则根据拒绝策略来处理该任务, 默认的处理方式是直接抛异常。
在这里插入图片描述

任务缓冲

线程池的本质是对任务和线程的管理：将任务和线程两者解耦，才可以做后续的分配工作。线程池中是以生产者消费者模式，通过一个阻塞队列来实现的。阻塞队列缓存任务，工作线程从阻塞队列中获取任务。
阻塞队列(BlockingQueue)是一个支持两个附加操作的队列：在队列为空时，获取任务的线程会等待队列变为非空；当队列满时，存储任务的线程会等待队列可用。
使用不同的队列可以实现不一样的任务存取策略。阻塞队列的成员有以下：
在这里插入图片描述

任务申请

一种是：任务直接由新创建的线程执行。另一种是：线程从任务队列中获取任务然后执行，执行完任务的空闲线程会再次去从队列中申请任务再去执行。

任务拒绝

任务拒绝模块是线程池的保护部分，线程池有一个最大的容量，当线程池的任务缓存队列已满，并且线程池中的线程数目达到maximumPoolSize时，就需要拒绝掉该任务，采取任务拒绝策略，保护线程池。

拒绝策略策略
AbortPolicy丢弃任务，并抛出异常：最大承载=maximumPoolSize + BlockingQueue
CallerRunsPolicy由提交任务的线程处理该任务
DiscardPolicy不处理新任务，直接丢弃掉
DiscardOldestPolicy丢弃队列最前面的任务，然后重新提交被拒绝的任务。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

//工具类 Executors 三大方法；
public class Test {
    public static void main(String[] args) {

        ExecutorService threadPool = Executors.newSingleThreadExecutor();//单个线程
        ExecutorService threadPool2 = Executors.newFixedThreadPool(5); //创建一个固定的线程池的大小
        ExecutorService threadPool3 = Executors.newCachedThreadPool(); //可伸缩的

        //线程池用完必须要关闭线程池
        try {

            for (int i = 1; i <=10 ; i++) {
                //通过线程池创建线程
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+ " ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }
    }
}

4 创建线程池的七大参数

参数特点
corePoolSize核心线程池大小：线程池中会维护一个最小的线程数量，即使这些线程处理空闲状态，他们也不会被销毁。当向线程池提交一个任务时，若线程池已创建的线程数小于corePoolSize，即便此时存在空闲线程，也会通过创建一个新线程来执行该任务，直到已创建的线程数大于或等于corePoolSize时，除了利用提交新任务来创建和启动线程（按需构造），也可以通过 prestartCoreThread() 或 prestartAllCoreThreads() 方法来提前启动线程池中的基本线程。
maximumPoolSize一个任务被提交到线程池以后，如果工作队列满了，才会创建一个新线程，然后从工作队列的头部取出一个任务交由新线程来处理，而将刚提交的任务放入工作队列尾部。线程池不会无限制的去创建新线程，它会有一个最大线程数量的限制，这个数量即由maximunPoolSize指定。
keepAliveTime一个线程如果处于空闲状态，并且当前的线程数量大于corePoolSize，那么在指定时间后，这个空闲线程会被销毁;如果allowCoreThreadTimeOut被设置为true时，无论线程数多少，线程处于空闲状态超过一定时间就会被销毁掉
TimeUnit unit超时单位
BlockingQueue workQueue用来保存等待被执行的任务的阻塞队列
ThreadFactory threadFactory为线程池提供创建新线程的线程工厂
RejectedExecutionHandler handler当工作队列中的任务已到达最大限制，并且线程池中的线程数量也达到最大限制，这时如果有新任务提交进来，会执行拒绝策略

5 你知道怎么创建线程池吗？

ThreadPoolExecutor() 是最原始的线程池创建，也是阿里巴巴 Java 开发手册中明确规范的创建线程池的方式。

public class Test {
    public static void main(String[] args) {
        // 获取cpu 的核数
        int max = Runtime.getRuntime().availableProcessors();
        ExecutorService service =new ThreadPoolExecutor(
                2,
                max,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );
        try {
            for (int i = 1; i <= 10; i++) {
                service.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "ok");
                });
            }
        }catch (Exception e) {
            e.printStackTrace();
        }
        finally {
            service.shutdown();
        }
    }
}

6 ThreadPoolExecutor

Java中的线程池核心实现类是ThreadPoolExecutor。ThreadPoolExecutor是如何运行，如何同时维护线程和执行任务的呢？
在这里插入图片描述
线程池在内部实际上构建了一个生产者消费者模型，将线程和任务两者解耦，并不直接关联，从而良好的缓冲任务，复用线程。线程池的运行主要分成两部分：任务管理、线程管理。
任务管理部分充当生产者的角色，当任务提交后，线程池会判断该任务后续的流转：
1 直接申请线程执行该任务；
2 缓冲到队列中等待线程执行；
3 拒绝该任务。

线程管理部分是消费者，它们被统一维护在线程池内，根据任务请求进行线程的分配，当线程执行完任务后则会继续获取新的任务去执行，最终当线程获取不到任务的时候，线程就会被回收。

7 如何优雅设置线程池的大小

线程池需要设置合适的大小，假如设置的太大，线程上线文切换过于频繁，造成大量资源开销，反而会使性能降低。假如设置的太小，存在很多可用的处理器资源却未在工作，会造成资源的浪费和对吞吐量造成损失。

为了充分利用处理器资源，创建的线程数至少要等于处理器核心数。如果所有的任务都是计算密集型的，那么线程数等于可用的处理器核心数就可以了。不过，如果所有的任务都是IO密集型，那么处理器大部分时间是空闲的，所有要适当的增加线程数。线程等待时间所占比例越高(IO密集型)，需要越多线程。线程运算时间所占比例越高(计算密集型)，需要越少线程。 于是可以使用下面的公式进行估算：

最佳线程数 = （1 + 线程等待时间/线程计算时间）* 目标CPU的使用率 * 处理器核心数

例如：平均每个线程计算运行时间为0.5s，而线程等待时间（非计算时间，比如IO）为1.5s，目标CPU的使用率是90%，CPU核心数为8，那么根据上面这个公式估算得到：(1 + 1.5/0.5) * 90% * 8 = 28.8。

即使有上面的简单估算方法，也许看似合理，但实际上也未必合理，都需要结合系统真实情况（比如是IO密集型或者是CPU密集型或者是纯内存操作）和硬件环境（CPU、内存、硬盘读写速度、网络状况等）来不断尝试达到一个符合实际的合理估算值，也可以尝试Dark Magic的估算方法。

8 线程池为什么要使用阻塞队列而不使用非阻塞队列？

阻塞队列可以保证任务队列中没有任务时阻塞获取任务的线程，使得线程进入wait状态，释放cpu资源。当队列中有任务时才唤醒对应线程从队列中取出消息进行执行。使得在线程不至于一直占用cpu资源。

9 线程池是如何保持核心线程不被摧毁呢?

1、客户端创建线程池对象后，调用execute() 提交一个Runnable任务；
2、execute()会调用addWorker() 创建一个Worker对象；
3、addWorker()内部会调用Worker.thread.start() 这时候实际调用的就是Worker对象内部的run方法；
4、Worker中的run方法委托给runWorker()执行；
5、runWorker()中有while循环体，不断地调用getTask()获取新任务；
6、在getTask()方法里它就是调用阻塞队列的poll()或take()等待获取其中的任务，getTask()通过调用blockQueue的take()获取队列中的任务，如果队列为空，就一直阻塞当前线程，利用了阻塞队列的特性，实现核心线程空闲时间，也保持live；

package com.thread.pool;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.stream.IntStream;

import static java.lang.Thread.sleep;

public class TestFixedThreadPool {
    public static void main(String[] args) {
        ExecutorService fixedThreadPool = getThreadPoolExecutorService_bk();
        fixedThreadPool.shutdown();
    }

    private static ExecutorService getFixedExecutorService() {
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        IntStream.rangeClosed(1, 5).forEach(
                item -> fixedThreadPool.execute(() -> {
                        try {
                            SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
                            System.out.println("运行时间 - " + sdf.format(new Date()) + " " + item);
                            sleep(2000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }));
        return fixedThreadPool;
    }

    private static ExecutorService getCachedExecutorService() {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        IntStream.rangeClosed(1, 10).forEach(
                item -> cachedThreadPool.execute(() -> {
                        try {
                            SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
                            System.out.println("运行时间 - " + sdf.format(new Date()) + " " + item);
                            sleep(2000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }}));
        return cachedThreadPool;
    }

    private static ExecutorService getSingleExecutorService() {
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        IntStream.rangeClosed(1, 8).forEach(
                item -> singleThreadExecutor.execute(() -> {
                    try {
                        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
                        System.out.println("运行时间 - " + sdf.format(new Date()) + " " + item);
                        sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }}));
        return singleThreadExecutor;
    }

    private static ExecutorService getScheduledExecutorService() {
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
        System.out.println("提交时间: " + sdf.format(new Date()));
        scheduledThreadPool.schedule(() ->
                System.out.println("运行时间: " + sdf.format(new Date())), 3, TimeUnit.SECONDS);

        scheduledThreadPool.scheduleAtFixedRate(() ->
                System.out.println("运行时间: " + sdf.format(new Date())), 1, 3, TimeUnit.SECONDS);

        return scheduledThreadPool;
    }

    private static ExecutorService getThreadPoolExecutorService() {
        int max = Runtime.getRuntime().availableProcessors();
        System.out.println(max);
        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,
                max,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
        IntStream.rangeClosed(1, 10).forEach(
                item -> threadPoolExecutor.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + " ok " + sdf.format(new Date()));
                    try {
                        sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                })
        );
        threadPoolExecutor.shutdown();
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(threadPoolExecutor.getPoolSize());
        return threadPoolExecutor;
    }

    /**
     * 由提交任务的线程处理该任务 不会丢弃任务
     * @return
     */
    private static ExecutorService getThreadPoolExecutorService_bk() {
        int max = Runtime.getRuntime().availableProcessors();
        System.out.println(max);
        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,
                2,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.CallerRunsPolicy());
        IntStream.rangeClosed(1, 10).forEach(
                item -> CompletableFuture.supplyAsync(() -> {
                    System.out.println(Thread.currentThread().getName() + " ok " + sdf.format(new Date()));
                    try {
                        sleep(3000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    return null;
                }, threadPoolExecutor)
        );
        threadPoolExecutor.shutdown();
        return threadPoolExecutor;
    }
}
@Autowire
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
谈谈你对线程池的理解
qq_46130027的博客
06-10 185
最后线程池里面的资源限制是通过几个关键参数来控制的。核心线程数表示默认长期存在的工作线程。而最大的线程数是根据任务的情况来动态创建的线程。简单来说，就是线程池里面的工作线程处于一直运行状态。因为线程本身并不是一个受控的技术，也就是说线程的生命周期是由任务的运行状态来决定的。也就是说工作线程是根据任务的情况来决定阻塞和唤醒。其中的动态扩容和缩容思想、线程的复用思想以及线程的回收方法等等。所以为了实现线程的复用，线程池里面用到了阻塞队列。它的主要目的是为了提高阻塞队列中任务的处理效率。
简述一下你对线程池的理解
qq_33240556的博客
01-02 431
线程池是一种在多线程编程中常见的技术，它用于管理和控制线程的创建和销毁。线程池提供了一种更有效的方式来管理和利用系统资源，特别是在处理大量重复任务的情况下。总的来说，线程池提供了一种更有效、更可控的方式来管理和利用系统资源，特别是在处理大量重复任务的情况下。
线程池的理解
qq_51730795的博客
05-18 254
一.什么是线程池 线程池其实就是一种多线程处理形式，处理过程中可以将任务添加到队列中，然后在创建线程后自动启动这些任务。这里的线程就是我们前面学过的线程,这里的任务就是我们前面学过的实现了Runnable或Callable接口的实例对象。 二.线程池的工作原理 三.使用线程池的好处 1:线程和任务分离,提升线程重用性; 2:控制线程并发数量,降低服务器压力,统一管理所有线程; 3:提升系统响应速度,假如创建线程用的时间为T1，执行任务用的时间为T2,销毁线程用的时间为T3，那么使用线程池就免去了T1和T3
对线程池的理解
m0_66944273的博客
09-29 2249
线程池是一种技术，使用线程池来管理维护线程，比手动创建更加安全，快捷，因为线程是一种稀缺资源，无限制的过度创建，可能会威胁到系统的稳定性，同时线程的创建和销毁都会付出额外的性能消耗，而线程池就像一个蓄水的池子，将线程都存放在里面，到需要的时候，可以直接去使用。
线程池详解
qq_37436172的博客
11-11 1861
什么是线程池 在面向对象编程中，创建和销毁对象是很费时间的，因为创建一个对象要获取内存资源或者其它更多资源。在Java中更是如此，虚拟机将试图跟踪每一个对象，以便能够在对象销毁后进行垃圾回收。所以提高服务程序效率的一个手段就是尽可能减少创建和销毁对象的次数，特别是一些很耗资源的对象创建和销毁，这就是”池化资源”技术产生的原因。线程池顾名思义就是事先创建若干个可执行的线程放入一个池（容器）中，需要的时候从池中获取线程不用自行创建，使用完毕不需要销毁线程而是放回池中，从而减少创建和销毁线程对象的开销。 Java
谈谈你对JVM的理解?
最新发布
03-26
谈谈你对JVM的理解?
谈谈Java 线程池
09-07
线程池不仅能够降低资源消耗，还能提高响应速度，并且方便对线程进行统一管理。 线程池的核心在于`ThreadPoolExecutor`类，它是Java `java.util.concurrent`包中的核心组件。创建线程池时，我们需要提供几个关键...
谈谈你对aja的理解(一、二)
10-23
Ajax是Asynchronous Javascript And XML的缩写，其作用通过Ajax可以使用Javascript语句来调用XMLHttpRequest对象，直接与服务器进行通讯，可以在不重载页面的情况下与服务器交换数据。
简单谈谈ThreadPoolExecutor线程池之submit方法
08-30
"ThreadPoolExecutor线程池之submit方法详解" 在 Java 中，ThreadPoolExecutor 是一个非常重要的线程池实现类，它提供了多种方式来执行任务，其中 submit 方法是其中一个重要的方法，本文将详细解释 ...
第01讲丨谈谈你对Java平台的理解？.html
11-26
第01讲丨谈谈你对Java平台的理解？.html
JAVA线程池
一名在校大三学习JAVA
06-29 945
目录池的思想JDK中线程池的使用线程池的核心父接口ExecutorService ThreadPoolExecutor子类的核心构造方法参数
java中线程和线程池问题总结
qq_37480069的博客
05-10 1213
线程和线程池的问题总结
【Java面试】说说你对线程池的理解
Zhangsama1的博客
12-09 237
面试官：小张，说一说你对线程池的理解
Java技术——多态的实现原理
weixin_30808575的博客
08-12 286
0．前言转载请标明出处：http://blog.csdn.net/seu_calvin/article/details/52191321多态在Java技术里有很重要的地位，在面试中也会经常被问到。多态的使用大家应该都比较了解，但是多态的实现原理就有点抽象了，查了很多很多资料，连续几天断断续续的看，有时候看着看着就走神了。毕竟太抽象，哈哈~不过依然硬着头皮看下来了（也不知道看了多少遍），并且将很...
线程的工作机制和资源损耗
xiaohuihui822的博客
04-13 968
线程工作机制和资源损耗线程创建新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 许多人认为在自己的应用中创建的线...
Java线程池理解
journey_fan的专栏
05-23 5249
线程池原理理解作用： 线程池的作用就是限制系统中执行线程的数量。 根据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果； 少了浪费系统资源，多了造成系统拥挤效率不高。 用线程池控制线程数量，其他线程排队等候。一个任务执行完毕，再从队列中取最前面的任务开始执行。 若队列中没有等待进程，线程池的这一资源处于等待。 当一个新任务需要运行时，如果线程池中有等待的工作线程
关于线程池的学习和理解（一）
kaluoye的博客
08-08 2147
   一、线程和线程池      关于线程大家都不陌生，官方说法线程作为进程执行的最小单位。线程池字面上理解就是一堆线程放在一起。打个比方，线程相当于小工，线程池相当于工程队。以前做任务A，招个小工过来，做任务B，招一个小工过来。。。。，这样的话就会出现一个问题，我招小工需要耗费时间精力，如果任务比较小，一会就做完了，那我费半天劲招个小工的时间都比干活的时间长，那我不是亏大了。因此，为了解决我频...
谈谈你对vueX的理解？
07-15
我对Vuex的理解是： 1. 状态管理：Vuex将应用的状态存储在一个全局的状态树中，称为store。这样可以方便地管理和跟踪应用的状态，所有的组件都可以访问这个store中的状态。 2. 单向数据流：Vuex遵循单向数据流的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值