线程池使用

最新推荐文章于 2023-06-14 15:00:39 发布
最新推荐文章于 2023-06-14 15:00:39 发布
阅读量194 收藏
点赞数
分类专栏： 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/suchenbin/article/details/101768795
版权
本文介绍了线程池的概念，强调了线程池在减少线程创建和销毁开销中的作用。文章列举了Java中Executors类提供的五种线程池类型：newCachedThreadPool用于短期异步任务，newFixedThreadPool保持固定数量线程，newSingleThreadExecutor确保任务按顺序执行，newScheduledThreadPool支持定时及周期性任务，newSingleThreadScheduledExecutor是其单线程版。每种类型的线程池特点和应用场景都有详细说明。
摘要由CSDN通过智能技术生成

线程池（来自百度百科）

一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。 例如，线程数一般取cpu数量+2比较合适，线程数过多会导致额外的线程切换开销。任务调度以执行线程的常见方法是使用同步队列，称作任务队列。池中的线程等待队列中的任务，并把执行完的任务放入完成队列中。

常见线程池

在Java中可以使用Executors类来创建线程池，Executors是静态工厂的功能，生产各种类型线程池。

1、newCachedThreadPool

创建一个可缓存的线程池。需要使用到线程时，会先从线程池中查找是否存在空闲的线程，如果没有线程可用，线程池能够根据需求创建新线程并放入线程池中，如果有线程可用，则直接使用可用的线程。线程执行完任务后，不会立即回收，会再次放回线程池，可以重用，缓存的线程60秒未使用则会被终止并移除。该线程池通常用于执行许多短期异步任务，能够有效提高程序的性能。

package com.su.mybatis.oracle.controller;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test {
 
    public static void main(String[] args) {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for(int i = 0;i<10;i++){
            final int num  = i;
//            try {
//                Thread.sleep(100);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
            cachedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "正在执行，num = " + num);
                }
            });
        }
        cachedThreadPool.shutdown();
        System.out.println("main执行完成");
    }
}

运行结果：

pool-1-thread-1正在执行，num = 0
pool-1-thread-2正在执行，num = 1
pool-1-thread-1正在执行，num = 7
pool-1-thread-3正在执行，num = 2
pool-1-thread-2正在执行，num = 8
main执行完成
pool-1-thread-4正在执行，num = 3
pool-1-thread-6正在执行，num = 5
pool-1-thread-7正在执行，num = 6
pool-1-thread-5正在执行，num = 4
pool-1-thread-8正在执行，num = 9

每次for循环中Thread.sleep(100);，运行结果：

pool-1-thread-1正在执行，num = 0
pool-1-thread-1正在执行，num = 1
pool-1-thread-1正在执行，num = 2
pool-1-thread-1正在执行，num = 3
pool-1-thread-1正在执行，num = 4
pool-1-thread-1正在执行，num = 5
pool-1-thread-1正在执行，num = 6
pool-1-thread-1正在执行，num = 7
pool-1-thread-1正在执行，num = 8
pool-1-thread-1正在执行，num = 9
main执行完成

2、newFixedThreadPool

创建一个线程数量固定的线程池，线程池会重用运行的线程来执行在共享的无边界队列上的任务。指定的线程数量n即线程的最大并发数，也就是说，在任何时候，至多n个线程主动处理任务。如果在所有线程都处于活动状态时提交了其他任务，则它们将在队列中等待线程可用。如果任何线程在关闭之前的执行过程中由于失败而终止，则在需要执行后续任务时将使用新线程来代替它。线程池中的线程将一直存在，直到主动关闭线程池。

package com.su.mybatis.oracle.controller;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test {
 
    public static void main(String[] args) {
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(4);
        for(int i = 0;i<10;i++){
            final int num  = i;
            fixedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "正在执行，num = " + num);
                }
            });
        }
        fixedThreadPool.shutdown();
        System.out.println("main执行完成");
    }
}

运行结果：

pool-1-thread-1正在执行，num = 0
pool-1-thread-2正在执行，num = 1
main执行完成
pool-1-thread-3正在执行，num = 2
pool-1-thread-1正在执行，num = 5
pool-1-thread-2正在执行，num = 4
pool-1-thread-2正在执行，num = 8
pool-1-thread-2正在执行，num = 9
pool-1-thread-4正在执行，num = 3
pool-1-thread-1正在执行，num = 7
pool-1-thread-3正在执行，num = 6

 3、newSingleThreadExecutor

创建一个单线程的线程池。（无边界队列中）所有任务都是通过这一个线程来执行，所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。如果这个单线程由于意外（eg：执行失败）而终止，并且需要执行后续任务，则会新线程将取代它。

package com.su.mybatis.oracle.controller;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test {
 
    public static void main(String[] args) {
        ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
        for(int i = 0;i<5;i++){
            final int num  = i;
            singleThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "正在执行，num = " + num);
                }
            });
        }
        singleThreadPool.shutdown();
        System.out.println("main执行完成");
    }
}

运行结果：

main执行完成
pool-1-thread-1正在执行，num = 0
pool-1-thread-1正在执行，num = 1
pool-1-thread-1正在执行，num = 2
pool-1-thread-1正在执行，num = 3
pool-1-thread-1正在执行，num = 4

 4、newScheduledThreadPool

 创建一个线程数量固定的线程池，可以定时或者周期性执行任务。使用继承ExecutorService的ScheduledExecutorService类。

1）、schedule，延迟执行。

package com.su.mybatis.oracle.controller;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Test {
 
    public static void main(String[] args) {
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(4);
        for(int i = 0;i<3;i++){
            final int num  = i;
            final long time1  = System.currentTimeMillis();
            scheduledThreadPool.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "正在执行，num = " + num
                            + "，延时:" + (System.currentTimeMillis()-time1) + "ms");
                }
            }, 2, TimeUnit.SECONDS);//延时2秒执行
        }
        scheduledThreadPool.shutdown();
        System.out.println("main执行完成");
    }
}

运行结果：

main执行完成
pool-1-thread-3正在执行，num = 2，延时:2002ms
pool-1-thread-1正在执行，num = 0，延时:2001ms
pool-1-thread-2正在执行，num = 1，延时:2002ms

2)、scheduleAtFixedRate，延时定时执行，上一个任务开始执行的时间 + 周期时间 = 下一个任务的开始时间。

package com.su.mybatis.oracle.controller;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Test {
 
    public static void main(String[] args) {
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(4);
        for(int i = 0;i<3;i++){
            final int num  = i;
            final long time1  = System.currentTimeMillis();
            scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(300);//线程休眠300毫秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在执行，num = " + num
                            + "，延时:" + (System.currentTimeMillis()-time1) + "ms");
                }
            }, 1, 2, TimeUnit.SECONDS);//延时2秒执行
        }
    }
}

运行结果：

pool-1-thread-1正在执行，num = 0，延时:1305ms
pool-1-thread-3正在执行，num = 2，延时:1302ms
pool-1-thread-2正在执行，num = 1，延时:1303ms
pool-1-thread-2正在执行，num = 1，延时:3303ms
pool-1-thread-1正在执行，num = 2，延时:3302ms
pool-1-thread-3正在执行，num = 0，延时:3304ms

3）、 scheduleWithFixedDelay，延时定时执行，上一个任务结束时间 + 周期时间 = 下一个任务的开始时间。

package com.su.mybatis.oracle.controller;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Test {
 
    public static void main(String[] args) {
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(4);
        for(int i = 0;i<3;i++){
            final int num  = i;
            final long time1  = System.currentTimeMillis();
            scheduledThreadPool.scheduleWithFixedDelay(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(300);//线程休眠300毫秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在执行，num = " + num
                            + "，延时:" + (System.currentTimeMillis()-time1) + "ms");
                }
            }, 1, 2, TimeUnit.SECONDS);//延时2秒执行
        }
    }
}

 运行结果：

pool-1-thread-1正在执行，num = 0，延时:1304ms
pool-1-thread-3正在执行，num = 2，延时:1301ms
pool-1-thread-2正在执行，num = 1，延时:1301ms
pool-1-thread-2正在执行，num = 2，延时:3604ms
pool-1-thread-3正在执行，num = 0，延时:3607ms
pool-1-thread-1正在执行，num = 1，延时:3604ms

5、newSingleThreadScheduledExecutor

 创建单线程的线程池，可以定时或者周期性执行任务。与4中的区别是它是单线程。

1）、schedule，延时执行

package com.su.mybatis.oracle.controller;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Test {
 
    public static void main(String[] args) {
        ScheduledExecutorService singleThreadScheduledThreadPool = Executors.newSingleThreadScheduledExecutor();
        for(int i = 0;i<3;i++){
            final int num  = i;
            final long time1  = System.currentTimeMillis();
            singleThreadScheduledThreadPool.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "正在执行，num = " + num
                            + "，延时:" + (System.currentTimeMillis()-time1) + "ms");
                }
            }, 2, TimeUnit.SECONDS);//延时2秒执行
        }
        singleThreadScheduledThreadPool.shutdown();
        System.out.println("main执行完成");
    }
}

 运行结果：

main执行完成
pool-1-thread-1正在执行，num = 0，延时:2002ms
pool-1-thread-1正在执行，num = 1，延时:2000ms
pool-1-thread-1正在执行，num = 2，延时:2000ms

2）、scheduleAtFixedRate，延时定时执行，上一个任务开始执行的时间 + 周期时间 = 下一个任务的开始时间。

package com.su.mybatis.oracle.controller;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Test {
 
    public static void main(String[] args) {
        ScheduledExecutorService singleThreadScheduledThreadPool = Executors.newSingleThreadScheduledExecutor();
        for(int i = 0;i<3;i++){
            final int num  = i;
            final long time1  = System.currentTimeMillis();
            singleThreadScheduledThreadPool.scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(300);//线程休眠300毫秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在执行，num = " + num
                            + "，延时:" + (System.currentTimeMillis()-time1) + "ms");
                }
            }, 1, 2, TimeUnit.SECONDS);//延时1秒，每2秒执行一次
        }
    }
}

 运行结果：

pool-1-thread-1正在执行，num = 0，延时:1302ms
pool-1-thread-1正在执行，num = 1，延时:1603ms
pool-1-thread-1正在执行，num = 2，延时:1905ms
pool-1-thread-1正在执行，num = 0，延时:3303ms
pool-1-thread-1正在执行，num = 1，延时:3603ms
pool-1-thread-1正在执行，num = 2，延时:3904ms

3）、scheduleWithFixedDelay，延时定时执行，上一个任务结束时间 + 周期时间 = 下一个任务的开始时间。

package com.su.mybatis.oracle.controller;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Test {
 
    public static void main(String[] args) {
        ScheduledExecutorService singleThreadScheduledThreadPool = Executors.newSingleThreadScheduledExecutor();
        for(int i = 0;i<3;i++){
            final int num  = i;
            final long time1  = System.currentTimeMillis();
            singleThreadScheduledThreadPool.scheduleWithFixedDelay(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(300);//线程休眠300毫秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在执行，num = " + num
                            + "，延时:" + (System.currentTimeMillis()-time1) + "ms");
                }
            }, 1, 2, TimeUnit.SECONDS);//延时1秒，每2秒执行一次
        }
    }
}

运行结果：

pool-1-thread-1正在执行，num = 0，延时:1304ms
pool-1-thread-1正在执行，num = 1，延时:1602ms
pool-1-thread-1正在执行，num = 2，延时:1902ms
pool-1-thread-1正在执行，num = 0，延时:3607ms
pool-1-thread-1正在执行，num = 1，延时:3905ms
pool-1-thread-1正在执行，num = 2，延时:4205ms

 以上就是常用线程池的使用方法，根据不同场景使用不同的线程池。

 

 

如果有写的不对的地方，请大家多多批评指正，非常感谢！

黑衣如墨剑如雪
关注
专栏目录
Python3 ThreadPoolExecutor--线程池
weixin_46135872的博客
08-12 2796
Python3 ThreadPoolExecutor
【Python3】线程池
最新发布
言之。
08-09 1万+
在 Python 3 中，使用线程池是并发编程的一个重要方式，通常可以通过 模块来实现。线程池可以让你并行地执行多个任务，并且能够方便地获取这些任务的结果。以下是一个示例，展示如何使用 来创建线程池、提交任务，并获取结果： 代码解析 定义任务函数：创建线程池：提交任务：获取任务结果： 还提供了 方法，能够更简单地处理任务和结果： 在这个示例中， 方法接受一个函数和一个可迭代对象，然后并行地将可迭代对象中的每个元素传递给函数执行。返回值是一个迭代器，按照任务提交的顺序生成结果。线程池的大小：异常处理
Python3 里面的线程池
weixin_30825581的博客
04-27 459
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor import time def task(i): print(i) time.sleep(1) pool = ThreadPoolExecutor(10) #先定义一个线程池 for index in range(64)...
python3线程池 多线程
qq_27886997的博客
09-27 1388
从Python3.2开始，标准库为我们提供了 concurrent.futures 模块，它提供了 ThreadPoolExecutor (线程池)和ProcessPoolExecutor (进程池)两个类。 相比 threading 等模块，该模块通过 submit 返回的是一个 future 对象，它是一个未来可期的对象，通过它可以获悉线程的状态主线程(或进程)中可以获取某一个线程(进程)执行的状态或者某一个任务执行的状态及返回值： 主线程可以获取某一个线程（或者任务的）的状态，以及返回值。 当一
[Python3] 线程池的使用
Tanzhouchi的博客
07-09 5732
认知： 对于多线程的作用，简单点就是把一项重复的任务分给多个渠道一起完成，这样就大大提高工作效率。 目前大多数使用线程用的都是threading模块，这模块对于现在来说我认为已经落后了，就拿爬虫来说，动不动就是处理百万千万级别的数据，处理那么大的数据量就需要控制线程的同步、等待、加锁等繁琐操作，这时，到python3就出现了线程池，解决了很多繁琐的操作。 这里我用到的模块是：concurrent.futures。 可以做到： 获取线程的运行状态和返回值。 不...
java线程池使用后到底要关闭吗
08-26
java线程池使用后到底要关闭吗 java线程池是一种高效的并发编程技术，可以帮助开发者更好地管理线程资源，提高系统的性能和可靠性。然而，在使用java线程池时，一个常见的问题是：使用完线程池后到底要不要关闭？...
C# 线程池使用示例
12-04
在VS2013环境下，结合控制台窗口，我们可以轻松地实现线程池的使用。下面将详细探讨C#线程池的工作原理、优势以及如何在实际项目中应用。 线程池的基本概念： 线程池是一组预先创建的线程，这些线程由操作系统维护...
Java线程池使用说明
02-24
使用线程池的好处有很多，比如减少了创建和销毁线程的次数，提高了程序性能；允许线程被重复利用，执行多个任务；可以根据系统承载能力动态调整线程池大小，避免服务器资源过度消耗。 在Java中，与线程池相关的几个...
c#线程池使用demo
10-31
在本示例"C#线程池使用demo"中，我们将探讨如何利用线程池来执行任务，以及其背后的原理和最佳实践。 首先，线程池主要由System.Threading命名空间下的ThreadPool类提供。在C#中，我们可以通过以下方式向线程池提交...
Python3并发编程之线程池/进程池--concurrent.futures模块
mengyangcust的博客
12-04 752
多线程应用编程中可能会使用到的一些模块： Python标准库为我们提供了threading和multiprocessing模块编写相应的多线程/多进程代码，但是当项目达到一定的规模，频繁创建/销毁进程或者线程是非常消耗资源的，这个时候我们就要编写自己的线程池/进程池，以空间换时间。但从Python3.2开始，标准库为我们提供了 concurrent.futures 模块，它提供了ThreadPo...
Python中线程池的实现(三)
超纯的小白兔
06-04 1327
# -*- coding: utf-8 -*- # Java 理论与实践: 线程池与工作队列: http://www.ibm.com/developerworks/cn/java/j-jtp0730/ # 线程池原理及python实现: http://www.cnblogs.com/goodhacker/p/3359985.html # Threadpool: http://chrisarndt
python3线程池的使用,Python 线程池用法简单示例
weixin_42525385的博客
03-25 536
本文实例讲述了Python 线程池用法。分享给大家供大家参考，具体如下：# -*- coding:utf-8 -*-#! python3'''Created on 2019-10-2@author: Administrator'''from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutorimport os,time,...
python 创建和使用线程池
weixin_45621200的博客
03-30 5644
众所周知，python3多线程有threading，很好的支持了多线程，那么问题来了，为什么还需要线程池呢，其实很好回答，如果你要爬取网站有八百页，每页设置一个线程，难道能开启八百个么，光切换的时间也很高了吧。这时候就需要用到线程池，可以设置一个20的线程池，同时只有20个县城在运行，剩下的排队。直接上讲解 线程池模块 在threading中是没有线程池相关功能的，想要运行线程池需要自己重写，很明显向我这么懒不可能重写，而且自己编写线程池很难写的比较完美，还需要考虑复杂情况下的线程同步，很容易发生死锁。所以
python3 线程池原理_Python3之并发(六)---线程池
weixin_29890919的博客
02-20 666
一、线程池系统频繁的启动新线程,线程执行完被销毁,如果线程不能被重复使用,即每个线程都需要经过启动、销毁和运行3个过程,这必然会使得系统的性能急剧下降,线程池的意义就在于减少线程创建及消毁过程中损失的系统资源线程池在程序运行时创建大量空闲线程,程序只需将要执行的任务交给线程池,线程池就会启动一个空闲的线程来执行,当任务执行完后,该线程并不会死亡销毁,而是再次返回到线程池中变成空闲状态,等待一下次被...
线程池使用Demo
05-06
线程池是Java并发编程中的重要概念，它是一种线程使用模式，用于高效地管理和执行大量并发任务。在Java中，我们主要通过`java.util.concurrent`包中的`ExecutorService`接口及其实现类来创建和管理线程池。线程池的...
Python 线程池
qq_36594703的博客
06-14 755
本文介绍了常用的两种线程池的实现方式，在多线程编程中能使用线程池就不要自己去创建线程，并不是说线程池实现的多么好，其实我们自己完全也可以实现一个功能更强大的线程池。但是其内置的线程池一来是受过全方面测试的，在安全性，性能和方便性上基本就是最优的了，同时线程池还替我们做了很多额外的工作，比如任务队列的维护，线程销毁时资源的回收等都不需要开发者去关心，我们只需注重业务逻辑即可，不需要在关心其他额外的工作，这将大大提高我们的的工作效率和使用感受。
python3 线程池源码解析_python线程池的实现实例
weixin_36300275的博客
12-28 447
python线程池的实现实例直接上代码：代码如下:# -*- coding: utf-8 -*-import Queueimport threadingimport urllibimport urllib2import osdef down(url,n):print 'item '+str(n)+' start 'filename=urllib2.unquote(url).decode('utf8...
python 3：多线程
sunshine_lyn的博客
07-30 693
以下两篇文章写得比较详细，可作为参考。 - https://www.cnblogs.com/jokerbj/p/7460260.html - http://www.dabeaz.com/python/UnderstandingGIL.pdf 下面出现的案例代码请看下一篇博文。 多线程 vs 多进程 程序：一堆代码以文本形式存入一个文档 进程： 程序运行的一个状态 包含地址空间，内存，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值