线程池的使用

Kyrie~Irving

已于 2023-06-28 19:54:55 修改

阅读量1.8k

点赞数 9

文章标签： java 开发语言线程池

于 2023-06-28 19:49:50 首次发布

本文链接：https://blog.csdn.net/m0_53714343/article/details/131438982

版权

一、线程池

1.1、线程池是什么？

字面意思就是，一次创建多个线程，放在一个池子里(集合类),用的时候拿出来一个，用完了就放回池子里就可以了。

1.2、为什么要使用线程池？

首先使用多线程编程就是为了提高效率，那么就需要创建很多线程。创建的过程是JVM通过系统API调用来申请系统线程的过程，虽然创建线程的开销比创建进程的开销小的多，但是也顶不住频繁的创建和销毁。

池化技术可以减少线程频繁的创建和销毁，从而提高程序的性能。

二、了解多线程场景

1、用一个集合去组织任务

2、一次性创建多个线程，不停的扫描任务集合

3、如果集合中有任务，那么就执行任务

4、如果集合中没有任务那就等待

三、标准库中的线程池

*使用Executors.newFixedThreadPool(3)能创建出固定包含三个线程的线程池.

*返回值类型为ExecutorService.

*通过ExecutorService.submit可以注册一个任务到线程池中.

ExecutorService pool = Executors.newFixedThreadPool(3);
pool.submit(new Runnable() {
  @Override
  public void run() {
    System.out.println("hello");
}
});

3.1、系统自带的线程池种类

//1、用来处理大量短时间工作任务的线程池，如果池中没有可用的线程将创建新的线程，如果线程空闲60秒将收回并移出缓存
ExecutorService cachedThreadPool= Executors.newCachedThreadPool();
//2、创建一个无界队列(没有大小限制)且固定大小的线程池
ExecutorService fixedThreadPool=Executors.newFixedThreadPool(3);
//3、创建一个操作无界队列且只有一个工作线程的线程池
ExecutorService singleThreadExecutor=Executors.newSingleThreadExecutor();
//4、创建一个单线程执行器，可以给定时间后执行或定期执行
ScheduledExecutorService singleThreadScheduleExecutor=Executors.newSingleThreadScheduledExecutor();
//5、创建一个指定大小的线程池，可以给定时间后执行或定期执行
ScheduledExecutorService scheduledThreadPool=Executors.newScheduledThreadPool(3);
//6、创建一个指定大小（不传入参数，为当前机器CPU核心数）的线程池，并行的处理任务，不保证处理顺序
Executors.newWorkStealingPool();

3.2、演示系统自带的线程池


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

/**
 * 演示系统自带的线程池
 */
public class Exe_01 {
    public static void main(String[] args) {
        //创建一个有三个线程的固定线程池
        ExecutorService newFixedThreadPool= Executors.newFixedThreadPool(3);
        //往线程池中添加任务
        newFixedThreadPool.submit(()->{
            System.out.println("全明星制作人们大家好!");
        });
        newFixedThreadPool.submit(()->{
            System.out.println("我是练习时长两年半的个人练习生");
        });
        newFixedThreadPool.submit(()->{
            System.out.println("咯咯");
        });
        newFixedThreadPool.submit(()->{
            System.out.println("你干嘛，哎呦");
        });
        //添加了多个任务，提交到线程池就执行了
        Thread thread=new Thread(() ->{
            for (int i = 0; i < 100; i++) {
                int task=i;
                newFixedThreadPool.submit(()->{
                    System.out.println("执行任务："+task+"...");
                });
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread.start();
    }
}

四、自定义实现线程池

1、管理任务的一个队列，可以用阻塞队列去实现。使用阻塞队列的好处是，当线程去取任务时，如果队列为空那么就阻塞等待，不会造成过多的CPU资源消耗.

2、提供一个往队列中添加任务的方法.

3、创建多个线程，扫描这个任务队列，如果有任务就拿出来执行.


import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * 实现一个线程池
 */
public class MyThreadPool {
    //定义一个阻塞队列来管理任务
    BlockingQueue<Runnable> queue=new LinkedBlockingQueue<>();
    //定义一个往队列添加任务的方法
    public void submit(Runnable runnable) throws InterruptedException {
        //把任务加入队列
        queue.put(runnable);
    }
    //提供一个创建线程数量的构造方法
    public MyThreadPool(int num){
        if(num<=0){
            throw new RuntimeException("线程数量不能小于0");
        }
        //创建线程
        for (int i = 0; i < num; i++) {
            Thread thread=new Thread(() ->{
                while(true){
                    try {
                        //从队列中获取任务
                        Runnable task = queue.take();
                        //执行任务
                        task.run();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            //启动线程
            thread.start();
        }
    }
}


public class Exe_03 {
    public static void main(String[] args) {
        MyThreadPool ThreadPool=new MyThreadPool(3);
        //提交任务
        for (int i = 0; i < 100; i++) {
            int task=i;
            try {
                ThreadPool.submit(()->{
                    System.out.println("执行任务："+task+"...");
                });
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

往线程池中添加任务就会自动执行

五、线程池的七个参数

1、下午想去吃个烧烤，最近有个”Ikun火锅店“非常火爆，去晚了要去排队。

2、烧烤店里面有五张桌子(核心线程数)，去了早了，店里没有人直接上桌就行。

3、越到饭店的时候人越来越多，这时五张桌子已经坐满了，那么就需要在外面抽个号排个队，最多可以排到20号(相当于阻塞队列，20是队列的大小) 。

4、排队的也越来越多，于是老板为了赚钱，就在外面加了10张桌子(临时线程)。

5、排号的人就可以在外面吃烧烤。

6、随着时间越来越晚，吃饭的人走的差不多了，外面的桌子也就空了出来，排队的人也没有了，再等30分钟(临时线程存活时间，和时间单位)没人就把桌子收起来。

7、等了一会，老板一看没有人了，外面的桌子也没有人坐了，就把外面的桌子收起来。

8、店里的那5张桌子(最后回归核心线程数)就可以满足上客的需求。

9、中途如果排号20号排满了，10张临时桌子也满了，老板就暂时不接待新客人了(相当于是拒绝策略)。

5.1、线程池的工作流程

5.2、拒绝策略

Java提供了四种拒绝策略

直接拒绝是系统默认策略

比如说，烧烤客满了，老板见到新的客人上门时，直接拒绝。

烧烤客满了，客人上门来，老板对客人说，你看见有空了你自己就找地方坐下，也就是说谁提交的任务就把这个任务退给谁，保证这个任务有线程执行就行。

最早进入阻塞队列的任务被无情抛弃。

新提交的任务全部抛弃掉，不理会。

抛弃的任务就没有拥有者，也就是抛弃了之后就再也找不回来了。

5.3、演示拒绝策略


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

/**
 * 演示拒绝策略
 */
public class Exe_05 {
    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor poolExecutor=new ThreadPoolExecutor(
                3,//核心线程数
                10,//最大线程数
                1,//临时线程的存活时间
                TimeUnit.SECONDS,//临时线程的存活单位
                new LinkedBlockingQueue<>(20),//阻塞队列的类型和大小
                new ThreadPoolExecutor.AbortPolicy());//直接拒绝策略
        for (int i = 0; i < 100; i++) {
            int task=i;
            poolExecutor.submit(()->{
                System.out.println("执行了任务"+task+",当前线程:"+Thread.currentThread());
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
    }
}

运行结果：