Android架构师必备技能 | 并发编程之线程池

最新推荐文章于 2024-07-31 17:21:46 发布

「已注销」

最新推荐文章于 2024-07-31 17:21:46 发布

阅读量152

点赞数

文章标签： android java

本文链接：https://blog.csdn.net/qq_44102588/article/details/120365993

版权

本文详细探讨了Java中的线程池，包括线程池的好处、四种类型的线程池(newSingleThreadExecutor, newFixedThreadPool, newScheduledThreadPool, newCachedThreadPool)的特性和应用场景，以及线程池任务执行流程和工作队列排队策略。通过实例分析，解释了不同线程池如何处理任务和线程的管理，帮助理解如何选择合适的线程池。" 120852649,9983500,Java判断数字是否为2的幂次方,"['Java', '编程算法', '位操作']

摘要由CSDN通过智能技术生成

线程池

Java的线程池是运用场景最多的并发框架，几乎所有需要异步或者并发执行任务的程序都可以使用线程池。

使用线程池能带来的好处：

降低资源消耗
提高响应速度
提高线程的可管理性

线程池底层实现分析

Java 中提供了四种线程池创建方法，分别是：

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

1，newSingleThreadExecutor

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

可以看到 corePoolSize、maximumPoolSize 都是 1 ，keepAliveTime 是 0 ，使用的是 LinkedBlockingQueue 队列。

解释：创建只有一个线程的线程池，且线程的存活时间是无限的；当该线程正繁忙时，对于新任务会进入阻塞队列中(无界的阻塞队列)

demo：

public class FourThreadPool {
   
    public static void main(String[] args) {
   
ScheduledThreadPoolExecutorTest().ScheduledThreadPoolExecutorTest();
        ExecutorService executorService = new newSingleThreadExecutor().newSingleThreadExecutor();

        for (int i = 0; i < 10; i++) {
   
            executorService.execute(new TestRunnable());
        }
        executorService.shutdown();
    }

}
class TestRunnable implements Runnable {
   
    static int i = 1;

    @Override
    public void run() {
   
        System.out.println(Thread.currentThread().getName() + "  线程被调用了。第" + getCount() + "次");
    }
    public static int getCount() {
   
        return i++;
    }
}
class newSingleThreadExecutor {
   

    ExecutorService newSingleThreadExecutor() {
   
        /**
         * 1
         * 此线程池 Executor 只有一个线程。它用于以顺序方式的形式执行任务。
         * 如果此线程在执行任务时因异常而挂掉，则会创建一个新线程来替换此线程，后续任务将在新线程中执行。
         */
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        return executorService;
    }
}

输出：

pool-1-thread-1  线程被调用了。第1次
pool-1-thread-1  线程被调用了。第2次
pool-1-thread-1  线程被调用了。第3次
pool-1-thread-1  线程被调用了。第4次
pool-1-thread-1  线程被调用了。第5次
pool-1-thread-1  线程被调用了。第6次
pool-1-thread-1  线程被调用了。第7次
pool-1-thread-1  线程被调用了。第8次
pool-1-thread-1  线程被调用了。第9次
pool-1-thread-1  线程被调用了。第10次

2，newFixedThreadPool

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

可以看到 corePoolSize 和 maximumPoolSize 一样，由调用者自己设定传入，keepAliveTime 是 0 ，使用的是 LinkedBlockingQueue 队列。

解释：创建可容纳固定数量线程的池子，每隔线程的存活时间是无限的，当池子满了就不在添加线程了；如果池中的所有线程均在繁忙状态，对于新任务会进入阻塞队列中(无界的阻塞队列)

可以看到上面两种线程池都是使用了 LinkedBlockingQueue ，而且默认使用的是 new LinkedBlockingQueue<Runnable>());

继续扒一下这个 LinkedBlockingQueue 的默认大小

public LinkedBlockingQueue() {
   
    this(Integer.MAX_VALUE);
}

竟然是 int 类型的最大值

@Native public static final int   MAX_VALUE = 0x7fffffff;

就是说这个队列里面可以放 2^31-1 = 2147483647 个任务。

demo:

public class FourThreadPool {
   
    public static void main(String[] args) {
   
ScheduledThreadPoolExecutorTest().ScheduledThreadPoolExecutorTest();
        ExecutorService executorService = new newFixedThreadPool().newFixedThreadPool();

        for (int i = 0; i < 10; i++) {
   
            executorService.execute(new TestRunnable()