Java多线程之线程池（合理分配资源）

痛定思痛。 2023-09-27 09:57 65阅读 0赞

## **前言必读** ##

> [读者手册（必读）\_云边的快乐猫的博客-CSDN博客][-CSDN]

一、故事讲解

1.故事

> 有一家月饼店开业了，店里面有3个核心员工，这些人负责月饼的制作，3人同时工作制作100个月饼，每个人做完自己的月饼就会忙着下一个月饼的制作。因为总不可能要100个员工来做这些月饼吧，那也太浪费了。这些月饼的制作顺序是按照先后排队等待被制作的。

> 中秋佳节来临了，这些月饼的单子一下子赶了起来。忙不过来那就只能请一些临时员工来帮忙，但是核心员工忙得过来就用不上临时员工了。同时根据这些核心员工和临时员工的工作能力来判断接单情况，超过工作情况就不接单了，等先忙完这些再说。忙完这些月饼的制作，临时员工就会被辞退的。

2.怎么判断忙不过来，该找临时员工了？

3个核心线程都在忙，100个任务都排满了，那就只能找临时员工了

3.详解：

月饼店---线程池

3个核心员工--3个核心线程

100个月饼---100个任务

临时员工---临时线程

辞退---销毁临时线程（自动销毁，不用手动去设置）

二、概念讲解

1.什么是线程池？

**答：**一个可以复用线程的技术

2.如果不用线程池会怎么样？

**答：** 如果用户每发起一个请求，后台就会创建一个新的线程来进行处理。而一直开新线程的开销是很大的，这样会严重影响系统的性能。

3.怎么创建线程池?

**答：**创建ExecutorService接口的实现类，创建方式有两种

4.创建线程过多导致的问题？

**答：** 创建线程过多会占用CPU资源的，导致卡顿

**三、两种线程池的创建方式**

**方式一：**使用ExecutorService的实现类ThreadPoolExecutor去自己创建一个线程池对象。

（1）处理Runnable任务

**步骤：**

1.创建Runnable线程类

2.在main方法里面创建**ExecutorService** pool = new **ThreadPoolExecutor**()；\---括号里面填上线程的定义规则

3.创建**Runnable** target = new MyRunnable();

4.创建线程pool.**execute**(target);

**代码例子：**

package bao;
    
    import java.util.concurrent.*;
    
    public class Test {
        public static void main(String[] args) {
            /* //一、1.自己定义一个线程池对象----多态的写法
            * 3个核心员工(3个核心线程)
            * 5个总员工，那就是临时工是2个（总线程5个）
            * 6s,TimeUnit.SECONDS----临时工没事干就被销毁辞退了
            * 员工最多只能5个
            * Executors.defaultThreadFactory()-----默认线程工厂
            *new ThreadPoolExecutor.AbortPolicy()-----拒绝别人
            * */
            ExecutorService pool = new ThreadPoolExecutor(3,5,6, TimeUnit.SECONDS,new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
            //5.new创建线程
            Runnable target = new MyRunnable();
            //线程多少来自于上面自定义
            //因为线程方法都一样。调用有可能一下子就调用线程4-3-1了，那剩余的有可能会分配到任务，有可能闲着
            pool.execute(target);//核心线程1
            pool.execute(target);//核心线程2
            pool.execute(target);//核心线程3
            //创建临时线程（线程名字都一样，5个不一定哪个是核心，哪个是临时，分辨不出来）
            pool.execute(target);//线程4
            pool.execute(target);//线程5
            //为什么一些超过5条线程还能运行不报错呢？比如线程池里面只有5个位置，但是看着这么多线程都在，以为可以调用超过5个，一旦调用超过了5个就会报错
            //关闭线程（几乎不会用到，了解了就好了）
            //pool.shutdownNow();立即强制关掉,即使任务没有完成也会被关掉，会丢失任务
            //pool.shutdown();等待任务完成后再关闭，相对柔和
        }
    }
    //二、创建线程对象类
    //2.创建线程类
    class MyRunnable implements Runnable{
        //3.重写run方法
        @Override
        public void run() {
            //4.定义线程要执行的任务
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName()+"输出了：月饼"+i);//Thread.currentThread().getName()可以知道当前哪个线程处理任务
            }
        }
    }

**运行结果：**

> pool-1-thread-3输出了：月饼0  
> pool-1-thread-1输出了：月饼0  
> pool-1-thread-2输出了：月饼0  
> pool-1-thread-1输出了：月饼1  
> pool-1-thread-3输出了：月饼1  
> pool-1-thread-1输出了：月饼2  
> pool-1-thread-2输出了：月饼1  
> pool-1-thread-1输出了：月饼3  
> pool-1-thread-3输出了：月饼2  
> pool-1-thread-1输出了：月饼4  
> pool-1-thread-2输出了：月饼2  
> pool-1-thread-3输出了：月饼3  
> pool-1-thread-2输出了：月饼3  
> pool-1-thread-3输出了：月饼4  
> pool-1-thread-1输出了：月饼0  
> pool-1-thread-3输出了：月饼0  
> pool-1-thread-2输出了：月饼4  
> pool-1-thread-3输出了：月饼1  
> pool-1-thread-1输出了：月饼1  
> pool-1-thread-3输出了：月饼2  
> pool-1-thread-1输出了：月饼2  
> pool-1-thread-3输出了：月饼3  
> pool-1-thread-1输出了：月饼3  
> pool-1-thread-3输出了：月饼4  
> pool-1-thread-1输出了：月饼4

（2）处理Callable任务

**步骤：**

1.创建Callable线程类

2.在main方法里面创建**ExecutorService** pool = new **ThreadPoolExecutor**()；\---括号里面填上线程的定义规则

3. 创建线程Future<String> f1 = pool.submit(new MyCallable(这里输入传入的值));

4.输出结果System.out.println(f1.get());//有异常直接抛出就好了

**代码例子：**

package bao;
    
    import java.util.concurrent.*;
    
    public class Test {
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            //二、4.自定义线程的规则(详情看上一题)
            ExecutorService pool = new ThreadPoolExecutor(3,5,6, TimeUnit.SECONDS,new ArrayBlockingQueue<>(5),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
            //5.把任务给线程池
            Future<String> f1 = pool.submit(new MyCallable(100));
            Future<String> f2 = pool.submit(new MyCallable(200));
            Future<String> f3 = pool.submit(new MyCallable(300));
            Future<String> f4 = pool.submit(new MyCallable(400));
            Future<String> f5 = pool.submit(new MyCallable(500));
            //6.输出结果
            System.out.println(f1.get());//有异常直接抛出就好了
            System.out.println(f2.get());
            System.out.println(f3.get());
            System.out.println(f4.get());
            System.out.println(f5.get());
        }
    }
    //一、1.创建线程任务类Callable
    class MyCallable implements Callable<String>{
        private int n;
        public MyCallable(int n){
            this.n=n;
        }
    //2.重写Call方法
    
        @Override
        public String call() throws Exception {
    //3.写线程要执行的具体任务代码
            int sum = 0;
            for (int i = 0; i < n; i++) {
                sum+=i;
            }
            return Thread.currentThread().getName()+"执行1-"+n+"的和是"+sum;
        }
    }

**运行结果：**

> pool-1-thread-1执行1-100的和是4950  
> pool-1-thread-2执行1-200的和是19900  
> pool-1-thread-3执行1-300的和是44850  
> pool-1-thread-2执行1-400的和是79800  
> pool-1-thread-3执行1-500的和是124750

**方式二：**使用**Executors**(线程池的工具类)调用方法返回不同特点的线程池对象。（不适合做大型互联网场景的线程池方案，阿里巴巴手册不允许使用）

这个方式使用的例子方式就是固定了线程的数量使用。

**步骤：**

1.创建线程类

2.在main方法里面创建ExecutorService pool = Executors.newFixedThreadPool(这里固定线程数量);

3.创建线程pool.execute(new MyRunnable());

**代码例子：**

package bao;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class Test {
        public static void main(String[] args) {
            //二、5.创建固定线程池数据的线程池
            ExecutorService pool = Executors.newFixedThreadPool(3);//这里固定线程池里面只能有3个线程
            //6.创建线程
            pool.execute(new MyRunnable());//线程1
            pool.execute(new MyRunnable());//线程2
            pool.execute(new MyRunnable());//线程3
            //创建多余的线程也不要了，看都不看，就算上面的线程睡眠了
        }
    }
    //一、1.创建线程对象类
    //2.创建线程类
    class MyRunnable implements Runnable{
        //3.重写run方法
        @Override
        public void run() {
            //4.定义线程要执行的任务
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName()+"输出了：月饼"+i);//Thread.currentThread().getName()可以知道当前哪个线程处理任务
            }
        }
    }

**运行结果：**

> pool-1-thread-3输出了：月饼0  
> pool-1-thread-2输出了：月饼0  
> pool-1-thread-1输出了：月饼0  
> pool-1-thread-2输出了：月饼1  
> pool-1-thread-3输出了：月饼1  
> pool-1-thread-2输出了：月饼2  
> pool-1-thread-1输出了：月饼1  
> pool-1-thread-2输出了：月饼3  
> pool-1-thread-3输出了：月饼2  
> pool-1-thread-2输出了：月饼4  
> pool-1-thread-1输出了：月饼2  
> pool-1-thread-3输出了：月饼3  
> pool-1-thread-1输出了：月饼3  
> pool-1-thread-3输出了：月饼4  
> pool-1-thread-1输出了：月饼4

**旁白：**线程池的出现就是为了避免资源的浪费，合理分配线程的资源，创建方式有两种，主要用第一种，第二种工具线程不建议使用。

[-CSDN]: https://blog.csdn.net/m0_52861000/article/details/128148568?spm=1001.2014.3001.5501