线程池的四种实现

最新推荐文章于 2023-06-06 14:23:53 发布

qq_40921842

最新推荐文章于 2023-06-06 14:23:53 发布

阅读量1k

点赞数

文章标签：多线程 java

本文链接：https://blog.csdn.net/qq_40921842/article/details/107221369

版权

一.四种常见的线程池详解

线程池的返回值ExecutorService简介：

  ExecutorService是Java提供的用于管理线程池的类。该类的两个作用：控制线程数量和重用线程

具体的4种常用的线程池实现如下：（返回值都是ExecutorService）

2.1 Executors.newCacheThreadPool()：可缓存线程池，先查看池中有没有以前建立的线程，如果有，就直接使用。如果没有，就建一个新的线程加入池中，缓存型池子通常用于执行一些生存期很短的异步型任务

示例代码：

package boss.bes.basedata.myutil.threadPool;

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

/**
 * @version V1.0
 * @ClassName NewCachedThreadPoolTest
 * @PackageName boss.bes.basedata.myutil.threadPool
 * @Description: (用一句话描述该文件做什么)
 * @date: 2020/7/8 17:22
 * @author: lang
 */
public class NewCachedThreadPoolTest {
    public static void main(String[] args) {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            try {
                // sleep可明显看到使用的是线程池里面以前的线程，没有创建新的线程
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            cachedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    // 打印正在执行的缓存线程信息
                    System.out.println(Thread.currentThread().getName()
                            + "正在被执行");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        cachedThreadPool.shutdown();
        //pool.shutdown();//平缓关闭，不允许新的线程加入，正在运行的都跑完即可关闭。
       // pool.shutdownNow();//暴力关闭。不允许新的线程加入，且直接停到正在进行的线程。
    }
}

输出结果：

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

线程池为无限大，当执行当前任务时上一个任务已经完成，会复用执行上一个任务的线程，而不用每次新建线程

2.2 Executors.newFixedThreadPool(int n)：创建一个可重用固定个数的线程池，以共享的无界队列方式来运行这些线程。
示例代码：

package boss.bes.basedata.myutil.threadPool;

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

/**
 * @version V1.0
 * @ClassName newFixedThreadPoolTest
 * @PackageName boss.bes.basedata.myutil.threadPool
 * @Description: 创建一个可重用固定个数的线程池，以共享的无界队列方式来运行这些线程;
 *               定长线程池的大小最好根据系统资源进行设置
 * @date: 2020/7/9 10:17
 * @author: lang
 */
public class newFixedThreadPoolTest {
    public static void main(String[] args) {
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {
            fixedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println(Thread.currentThread().getName() + "正在执行");
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

输出结果：

pool-1-thread-1正在被执行
pool-1-thread-2正在被执行
pool-1-thread-3正在被执行
pool-1-thread-1正在被执行
pool-1-thread-2正在被执行
pool-1-thread-3正在被执行
pool-1-thread-1正在被执行
pool-1-thread-2正在被执行
pool-1-thread-3正在被执行
pool-1-thread-1正在被执行

因为线程池大小为3，每个任务输出打印结果后sleep 2秒，所以每两秒打印3个结果。
定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()

2.3 Executors.newScheduledThreadPool(int n)：创建一个定长线程池，支持定时及周期性任务执行
延迟执行示例代码：

package boss.bes.basedata.myutil.threadPool;

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

/**
 * @version V1.0
 * @ClassName NewScheduledThreadPool
 * @PackageName boss.bes.basedata.myutil.threadPool
 * @Description: 创建一个定长线程池，支持定时及周期性任务执行
 * @date: 2020/7/9 10:44
 * @author: lang
 */
public class NewScheduledThreadPool {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        //延迟1秒执行
        scheduledThreadPool.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("延迟1秒执行");
            }
        }, 1, TimeUnit.SECONDS);

        //延迟1秒后每3秒执行一次
        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("延迟1秒后每3秒执行一次");
            }
        }, 1, 3, TimeUnit.SECONDS);

    }

}

输出结果：

延迟1秒后每3秒执行一次
延迟1秒后每3秒执行一次
…

2.4 Executors.newSingleThreadExecutor()：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
示例代码：

package boss.bes.basedata.myutil.threadPool;

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

/**
 * @version V1.0
 * @ClassName NewSingleThreadExecutorTest
 * @PackageName boss.bes.basedata.myutil.threadPool
 * @Description: 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，
 *              保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
 * @date: 2020/7/9 10:23
 * @author: lang
 */
public class NewSingleThreadExecutorTest {
    public static void main(String[] args) {
        //创建一个单线程化的线程池
        ExecutorService singleThreadExcutor= Executors.newSingleThreadExecutor();
        for (int i=0;i<10;i++){
            final int index=i;
            singleThreadExcutor.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println(Thread.currentThread().getName()+"正在被执行，"+index);
                    Thread.sleep(5000);
                    }
                    catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

输出结果：

pool-1-thread-1正在被执行,打印的值是:0
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

三、缓冲队列BlockingQueue和自定义线程池ThreadPoolExecutor

1. 缓冲队列BlockingQueue简介：

BlockingQueue是双缓冲队列。BlockingQueue内部使用两条队列，允许两个线程同时向队列一个存储，一个取出操作。在保证并发安全的同时，提高了队列的存取效率。

2. 常用的几种BlockingQueue：

ArrayBlockingQueue（int i）:规定大小的BlockingQueue，其构造必须指定大小。其所含的对象是FIFO顺序排序的。

LinkedBlockingQueue（）或者（int i）:大小不固定的BlockingQueue，若其构造时指定大小，生成的BlockingQueue有大小限制，不指定大小，其大小有Integer.MAX_VALUE来决定。其所含的对象是FIFO顺序排序的。

PriorityBlockingQueue（）或者（int i）:类似于LinkedBlockingQueue，但是其所含对象的排序不是FIFO，而是依据对象的自然顺序或者构造函数的Comparator决定。

SynchronizedQueue（）:特殊的BlockingQueue，对其的操作必须是放和取交替完成。

3. 自定义线程池（ThreadPoolExecutor和BlockingQueue连用）

自定义线程池，可以用ThreadPoolExecutor类创建，它有多个构造方法来创建线程池。

常见的构造函数：ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue)

示例代码：

package boss.bes.basedata.myutil.threadPool;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @version V1.0
 * @ClassName ThreadPoolExecutorTest
 * @PackageName boss.bes.basedata.myutil.threadPool
 * @Description: (用一句话描述该文件做什么)
 * @date: 2020/7/8 15:29
 * @author: lang
 */
public class ThreadPoolExecutorTest {
    public static void main(String[]args){
        ThreadPoolExecutor pool=new ThreadPoolExecutor(1, 20, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<>(2));
        // 任务1
        pool.execute(() -> {
            try {
                Thread.sleep(3 * 1000);
                System.out.println("--helloWorld_001--  " + Thread.currentThread().getName()+1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        //任务2
        pool.execute(() -> System.out.println("--helloWorld_002--  " + Thread.currentThread().getName()+2));
        pool.shutdown();
    }
}

四、总结

1、线程池流程：

在这里插入图片描述 1、判断核心线程池是否已满，没满则创建一个新的工作线程来执行任务。已满则。
2、判断任务队列是否已满，没满则将新提交的任务添加在工作队列，已满则。
3、判断整个线程池是否已满，没满则创建一个新的工作线程来执行任务，已满则执行饱和策略。

（1、判断线程池中当前线程数是否大于核心线程数，如果小于，在创建一个新的线程来执行任务，如果大于则
2、判断任务队列是否已满，没满则将新提交的任务添加在工作队列，已满则。
3、判断线程池中当前线程数是否大于最大线程数，如果小于，则创建一个新的线程来执行任务，如果大于，则执行饱和策略。）

2、如何配置线程池

CPU密集型任务
尽量使用较小的线程池，一般为CPU核心数+1。因为CPU密集型任务使得CPU使用率很高，若开过多的线程数，会造成CPU过度切换。

IO密集型任务
可以使用稍大的线程池，一般为2*CPU核心数。 IO密集型任务CPU使用率并不高，因此可以让CPU在等待IO的时候有其他线程去处理别的任务，充分利用CPU时间。

混合型任务
可以将任务分成IO密集型和CPU密集型任务，然后分别用不同的线程池去处理。只要分完之后两个任务的执行时间相差不大，那么就会比串行执行来的高效。
因为如果划分之后两个任务执行时间有数据级的差距，那么拆分没有意义。
因为先执行完的任务就要等后执行完的任务，最终的时间仍然取决于后执行完的任务，而且还要加上任务拆分与合并的开销，得不偿失。

3、java中提供的线程池

Executors类提供了4种不同的线程池：newCachedThreadPool, newFixedThreadPool, newScheduledThreadPool, newSingleThreadExecutor

在这里插入图片描述 java线程池对比
1、newCachedThreadPool：用来创建一个可以无限扩大的线程池，适用于负载较轻的场景，执行短期异步任务。（可以使得任务快速得到执行，因为任务时间执行短，可以很快结束，也不会造成cpu过度切换）

2、newFixedThreadPool：创建一个固定大小的线程池，因为采用无界的阻塞队列，所以实际线程数量永远不会变化，适用于负载较重的场景，对当前线程数量进行限制。（保证线程数可控，不会造成线程过多，导致系统负载更为严重）

3、newSingleThreadExecutor：创建一个单线程的线程池，适用于需要保证顺序执行各个任务。

4、newScheduledThreadPool：适用于执行延时或者周期性任务。

4、execute()和submit()方法

1、execute()，执行一个任务，没有返回值。
2、submit()，提交一个线程任务，有返回值。
submit(Callable task)能获取到它的返回值，通过**future.get()**获取（阻塞直到任务执行完）。一般使用FutureTask+Callable配合使用（IntentService中有体现）。

submit(Runnable task, T result)能通过传入的载体result间接获得线程的返回值。
submit(Runnable task)则是没有返回值的，就算获取它的返回值也是null。

Future.get方法会使取结果的线程进入阻塞状态，知道线程执行完成之后，唤醒取结果的线程，然后返回结果。

qq_40921842

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
线程池的四种实现

一.四种常见的线程池详解线程池的返回值ExecutorService简介： ExecutorService是Java提供的用于管理线程池的类。该类的两个作用：控制线程数量和重用线程具体的4种常用的线程池实现如下：（返回值都是ExecutorService）2.1 Executors.newCacheThreadPool()：可缓存线程池，先查看池中有没有以前建立的线程，如果有，就直接使用。如果没有，就建一个新的线程加入池中，缓存型池子通常用于执行一些生存期很短的异步型任务示例代码：
复制链接

扫一扫