多线程案例

悠悠 2023-10-04 19:07 57阅读 0赞

### 多线程案例(代码要熟练掌握) ###

#### 文章目录 ####

*   *  多线程案例(代码要熟练掌握)
     *   *  单例模式
         *  阻塞式队列
         *   *  阻塞队列是什么
             *  生产者消费者模型
             *  阻塞队列实现
         *  定时器
         *   *  标准库中的定时器
             *  自己实现定时器
         *  线程池
         *   *  经典的面试题: \`ThreadPoolExecutor\`的构造方法的参数都是啥意思?
             *  Executors 创建线程池
             *  当前我们看到了两组线程池的使用风格.一个简单,一个复杂,用哪种更好?
             *  工厂模式

#### 单例模式 ####

单例模式能保证**某个类在程序中只存在唯一 一份实例**, 而不会创建出多个实例.  
这一点在很多场景上都需要. 比如 `JDBC` 中的 `DataSource` 实例就只需要一个.

单例模式具体的实现方式，分成**饿汉**和**懒汉**两种.  
饿汉模式:`static`在类加载阶段就把实例创建出来.  
懒汉模式:通过`getlnstance`方法来获取到实例.首次调用该方法的时候，才真正创建实例. (懒加载延时加载)

/**
     * 饿汉模式
     */
    public class ThreadDemo20 {
        
        static class Singleton{
        
            //把构造方法设为private,防止类外面调用构造方法,也就防止了调用者再其他地方创建该实例
            private Singleton(){
        
    
            }
            private static Singleton instance = new Singleton();
    
            private static Singleton getInstance(){
        
                return instance;
            }
        }
    }

如果多个线程调用`getInstance` ,是否出现线程安全问题??  
**对于饿汉模式的代码，是线程安全的.当前是多个线程读操作,不涉及修改操作**

/**
     * 懒汉模式
     */
    public class ThreadDemo21 {
        
        static class Singleton{
        
            private Singleton(){
         }
    
            private static Singleton instance = null;
    
           public static Singleton getInstance(){
        
                //instance == null相当于读操作
                if (instance == null){
        
                    //赋值相当于修改操作
                    instance = new Singleton();
                }
                return instance;
            }
        }
    
        public static void main(String[] args) {
        
            //通过这个方法来获取的实例,就能保证只有唯一的实例
            Singleton instance = Singleton.getInstance();
        }
    }

如果**实例已经创建完毕**,后续再调用`getInstance` ,此时不涉及修改操作.此时仍然是线程安全的  
但是**如果实例尚未创建**,此时就可能会涉及修改.**如果确实存在多个线程同时修改**,**就会涉及到线程安全问题!!!**

![在这里插入图片描述][e417efb9dcab4d8596b96b3d0e9936be.jpeg_pic_center]

![在这里插入图片描述][a5be33ae787444abb7be0ee75f44cdb2.jpeg_pic_center]

#### 阻塞式队列 ####

##### 阻塞队列是什么 #####

阻塞队列是一种特殊的队列. 也遵守 “**先进先出**” 的原则.  
阻塞队列能是一种**线程安全**的数据结构, 并且具有以下特性:  
当**队列满**的时候, **继续入队列就会阻塞**, 直到有其他线程从队列中取走元素.  
当**队列空**的时候, **继续出队列也会阻塞**, 直到有其他线程往队列中插入元素.  
阻塞队列的一个典型应用场景就是 “生产者消费者模型”. 这是一种非常典型的开发模型.

import java.util.concurrent.BlockingQueue;
    import java.util.concurrent.LinkedBlockingDeque;
    
    /**
     * 阻塞队列
     */
    public class ThreadDemo22 {
        
        public static void main(String[] args) throws InterruptedException {
        
            //BlockingQueue是一个接口是不可以直接实例化的,但LinkedBlockingDeque是基于它实现的
            //10代表最大容量,超过了继续插入就会阻塞
            BlockingQueue<String> queue = new LinkedBlockingDeque<>(10);
    
            //虽然offer和put都可以有插入功能,但是offer不提供阻塞功能.所以这里更推荐使用put
            //queue.offer("hello");
            queue.put("hello");
    
            //取元素
            String elem = queue.take();
            System.out.println(elem);
            elem = queue.take();//只有一个元素,所以代码运行到这里就阻塞了
            System.out.println(elem);
        }
    }

![在这里插入图片描述][dd18bcf423b84ec1a484f95809772271.jpeg_pic_center]

##### 生产者消费者模型 #####

生产者消费者模式就是**通过一个容器**来解决生产者和消费者的强耦合问题。  
生产者和消费者彼此之间不直接通讯，而**通过阻塞队列来进行通讯**，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取.

**生产者消费者模型最大的用途:1.解耦合,2.削峰填谷**

1.  **阻塞队列就相当于一个缓冲区**，平衡了生产者和消费者的处理能力.  
    比如在 “秒杀” 场景下, 服务器同一时刻可能会收到大量的支付请求. 如果直接处理这些支付请求,服务器可能扛不住(每个支付请求的处理都需要比较复杂的流程). 这个时候就可以把这些请求都放到一个阻塞队列中, 然后再由消费者线程慢慢的来处理每个支付请求. 这样做可以有效进行 “削峰”, 防止服务器被突然到来的一波请求直接冲垮.

现实生活中就像三峡大坝,**汛期**如果没有大坝,下游的水就很大,可能就有水灾(**关闸蓄水功能相当于削峰**),**旱期**如果没有大坝，下游的水就很少,可能就旱灾(**开闸放水相当于填谷**)

1.  **阻塞队列也能使生产者和消费者之间 解耦合**.  
    比如过年一家人一起包饺子. 一般都是有明确分工, 比如一个人负责擀饺子皮, 其他人负责包. 擀饺子皮的人就是 “生产者”, 包饺子的人就是 “消费者”.  
    擀饺子皮的人不关心包饺子的人是谁(能包就行, 无论是手工包, 借助工具, 还是机器包), 包饺子的人也不关心擀饺子皮的人是谁(有饺子皮就行, 无论是用擀面杖擀的, 还是拿罐头瓶擀, 还是直接从超市买的).

![在这里插入图片描述][bcaf1d15c8f24860a7446ecf2bbee12e.jpeg_pic_center]

import java.util.concurrent.BlockingQueue;
    import java.util.concurrent.LinkedBlockingQueue;
    
    /**
     * 生产者,消费者模型
     */
    public class ThreadDemo23 {
        
        public static void main(String[] args) {
        
            //使用BlockingQueue作为交易场所
            BlockingQueue<Integer> queue = new LinkedBlockingQueue<>();
    
            //搞一个线程作为消费者
            Thread customer = new Thread(){
        
                @Override
                public void run() {
        
                    while (true) {
        
                        //取队首元素
                        try {
        
                            Integer value = queue.take();
                            System.out.println("消费元素:" + value);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                }
            };
            customer.start();
    
            //搞一个线程作为生产者
            Thread producer = new Thread(){
        
                @Override
                public void run() {
        
                    for (int i = 1; i < 10000; i++) {
        
                        System.out.println("生产元素:" + i);
                        try {
        
                            queue.put(i);
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                }
            };
            producer.start();
    
            try {
        
                customer.join();
                producer.join();
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
        }
    }

##### 阻塞队列实现 #####

上面代码是标准库中的阻塞队列,下面我们手动实现一个相同功能的阻塞队列

通过 “循环队列” 的方式来实现. 使用 `synchronized` 进行加锁控制.  
`put` 插入元素的时候, 判定如果队列满了, 就进行 `wait`. (注意, 要在循环中进行 `wait`. 被唤醒时不一定队列就不满了, 因为同时可能是唤醒了多个线程).  
`take` 取出元素的时候, 判定如果队列为空, 就进行 `wait`. (也是循环 `wait`)

![在这里插入图片描述][3d2564db946049ab8680bd76181d93e7.jpeg_pic_center]

/**
     * 自己写一个简单版本的BlockingQueue
     * 数组实现队列，其实就是"循环队列"
     * 这里的操作就涉及到前面所介绍的synchronized wait notify了
     */
    public class ThreadDemo24 {
        
        static class BlockingQueue{
        
            //定义最大容量为1000,不考虑扩容问题
            private int[] items = new int[1000];
            private int head = 0;
            private int tail = 0;
            private int size = 0;
            private Object locker = new Object();
    
            //put用来入队列
            public void put(int item) throws InterruptedException {
        
                synchronized (locker) {
        
                    //入队列，就把新的元素给放到tail位置上，
                    //此处的条件最好写作while 而不是if
                    // 否则 notifyAll 的时候, 该线程从 wait 中被唤醒,
    			   // 但是紧接着并未抢占到锁. 当锁被抢占的时候, 可能又已经队列满了就只能继续等待
                    //如果是有多个线程阻塞等待的时候，万一同时唤醒了多个线程，
                    //就有可能出现，第一个线程放入元素之后，第二个线程相放，就又满了的情况。
                    //虽然当前take的代码中使用的是notify，一次只唤醒一个等待的线程，用if也不算错.
                    //但是，使用while 还是更稳健一 些.
                    //使用while的意思就是，保证wait被唤醒的时候能够再确认一次队列确实不满.
                    while(size == items.length){
        
                        //此时队列满了就要阻塞了
                        locker.wait();
                    }
                    items[tail] = item;
                    tail++;
                    //如果达到末尾就要回到起始位置了(循环功能)
                    if(tail >= items.length){
        
                        tail = 0;
                    }
                    //这个方法也可以的
                    //tail %= items.length;
                    size++;
                    locker.notify();
                }
            }
    
            //take用来出队列
            public int take() throws InterruptedException {
        
                int ret = 0;
                synchronized (locker) {
        
                    while(size == 0){
        
                        //对于阻塞队列来说,如果队列为空,再尝试取元素就会阻塞
                        locker.wait();
                    }
                    ret = items[head];
                    head++;
                    if(head >= items.length){
        
                        head = 0;
                    }
                    size--;
                    //此处的notify用来唤醒put中的wait
                    locker.notify();
                }
                return ret;
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
        
          /*  //测试用例
            BlockingQueue queue = new BlockingQueue();
            queue.put(1);
            queue.put(2);
            queue.put(3);
            queue.put(4);
    
            int elem = 0;
            elem = queue.take();
            System.out.println(elem);
            elem = queue.take();
            System.out.println(elem);
            elem = queue.take();
            System.out.println(elem);
            elem = queue.take();
            System.out.println(elem);*/
    
            BlockingQueue queue = new BlockingQueue();
            //消费者线程
            Thread consumer = new Thread(){
        
                @Override
                public void run() {
        
                    while (true) {
        
                        try {
        
                            int elem = queue.take();
                            System.out.println("消费者元素:" + elem);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                }
            };
            consumer.start();
    
            //生产者线程
            Thread producer = new Thread(){
        
                @Override
                public void run() {
        
                    for (int i = 1; i < 10000; i++) {
        
                        System.out.println("生产元素:" + i);
                        try {
        
                            queue.put(i);
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                    }
                }
            };
            producer.start();
    
            consumer.join();
            producer.join();
        }
    }

#### 定时器 ####

定时器也是软件开发中的一个重要组件. 类似于一个 “闹钟”. 达到一个设定的时间之后, 就执行某个指定好的代码.

##### 标准库中的定时器 #####

标准库中提供了一个 `Timer` 类. `Timer` 类的核心方法为 `schedule .`  
`schedule` 包含两个参数. 第一个参数指定即将要执行的任务代码, 第二个参数指定多长时间之后执行 (单位为毫秒).

import java.util.Timer;
    import java.util.TimerTask;
    /**
     * 标准库中的定时器
     */
    public class ThreadDemo25 {
        
        public static void main(String[] args) {
        
            System.out.println("代码开始执行!");
            Timer timer = new Timer();
            //核心用法 timer.schedule(new TimerTask()
            timer.schedule(new TimerTask() {
        
                @Override
                public void run() {
        
                    System.out.println("触发定时器!");
                }
            },3000);
        }
    }

##### 自己实现定时器 #####

定时器的实现  
思路:一个定时器里面是可以安排很多任务的,这些任务就会按照时间,谁先到了时间,就先执行谁.  
**描述任务:就可以直接使用Runnable来描述这个任务.**  
**组织任务:就需要有一个数据结构,把很多的任务给放到一起**  
此处的需求是需要能够在一大堆任务中, 找到那个最先时间到点的任务应用**优先队列**!!!  
此处最好使用**带阻塞功能的优先队列**来保证线程安全正好标准库中本来也就提供了这样的阻塞功能的优先队列 .  
提供一个`schedule`方法,这个方法就是往阻塞队列中插入元素就行了.还需要让`timer`内部有一个线程,这**个线程一直去扫描队首元素**,看看队首元素是不是已经到点了.如果到点就执行这个任务!!如果没到点,就把这个队首元素再塞回队列中,后续继续扫描

**代码流程如下**

1.  Timer类提供的核心接口为schedule,注册一个任务, 并指定这个任务多长时间后执行.
2.  Task于描述一个任务(作为 Timer的内部类).里面包含一个Runnable对象和一个time(毫秒时间戳)  
    **这个对象需要放到优先队列中.因此需要实现`Comparable`接口.**
3.  Timer实例中,通过`PriorityBlockingQueue`来组织若干个Task对象.  
    通过schedule来往队列中插入一个个Task对象.
4.  Timer类中存在一个worker线程,一直不停的扫描队 首元素,看看是否能执行这个任务.  
    **所谓"能执行”指的是该任务设定的时间已经到达了.**  
    但是当前这个代码中存在**一个严重的问题, 就是while (true) 转的太快了,造成了无意义的CPU浪费.**  
    比如第一个任务设定的是 1 min之后执行某个逻辑.但是这里的while (true)会导致每秒钟访问队首元素几万次.而当前距离任务执行的时间还有很久呢.
5.  **引入一个`locker`对象**,借助该对象的wait / notify来解决while (true)的**忙等问题**.  
    修改Worker的run方法,引入wait,等待一定的时间.  
    修改Timer的`schedule`方法,每次有新任务到来的时候唤醒一下 worker线程. (因为新插入的任务可能是需要马上执行的).

import java.util.concurrent.PriorityBlockingQueue;
    /**
     * 自己实现一个计时器
     * 难点解决忙等问题
     */
    public class ThreadDemo26 {
        
        //该类功能是描述任务,自定义字段比较大小需要重写比较方法
        static class Task implements Comparable<Task>{
        
            //command 表示这个任务是什么
            private Runnable command;
            //time表示这个任务什么时候到时间,单位是ms
            private long time;
    
            //约定传入的参数time是一个时间差, this.time来保存一个绝对时间戳
            public Task(Runnable command, long time) {
        
                this.command = command;
                this.time = System.currentTimeMillis() + time;
            }
    
            public void run(){
        
                command.run();
            }
    
            @Override
            public int compareTo(Task o) {
        
                //想要时间短的在前面,时间长的在后面(升序排序)
                return (int)(this.time - o.time);
            }
        }
    
        static class Timer{
        
            //使用这个带优先级的阻塞队列来组织任务
            private PriorityBlockingQueue<Task> queue = new PriorityBlockingQueue<>();
            //使用这个locker对象来解决忙等问题
            private Object locker = new Object();
    
            public void schedule(Runnable command, long delay){
        
                Task task = new Task(command,delay);
                queue.put(task);
    
                //每次插入任务都要唤醒扫描线程,让线程能够重新计算wait的时间,保证新的任务不会错过时间
                synchronized (locker){
        
                    locker.notify();
                }
            }
    
            public Timer(){
        
                //创建一个构造方法功能是来扫描线程,判断当前的任务是不是到时间能执行了
                Thread t = new Thread(){
        
                    @Override
                    public void run() {
        
                        while(true){
        
                            //取出队列首元素,判断时间
                            try {
        
                                Task task = queue.take();
                                long curTime = System.currentTimeMillis();//当前时间
                                if(task.time > curTime){
        
                                    //时间还没到,不用执行.但是前面的take()操作已经把队首元素取出并且删除了
                                    //所以要重新插回到队列中
                                    queue.put(task);
                                    //此处会发生忙等问题,白白的浪费CPU运转
                                    //解决办法:计算出等待时间查,这段时间wait调入阻塞队列
                                    synchronized (locker){
        
                                        locker.wait(task.time - curTime);
                                    }
                                }else{
        
                                    //时间到了
                                    task.run();
                                }
                            } catch (InterruptedException e) {
        
                                e.printStackTrace();
                                break;//如果出现了interrupt方法,能够退出线程
                            }
                        }
                    }
                };
                t.start();
    
            }
        }
    
        public static void main(String[] args) {
        
            System.out.println("程序启动!");
            Timer timer = new Timer();
            timer.schedule(new Runnable() {
        
                @Override
                public void run() {
        
                    System.out.println("hello");
                }
            },3000);
        }
    }

#### 线程池 ####

本来**多进程就是解决并发编程的方案.但是进程有点太重量了**. (创建和销毁,开销比较大)  
因此引入了线程.线程比进程要轻量很多.  
即便如此,如果某些场景中,需要频繁的创建销毁线程,此时,线程的创建销毁开销,也就无法忽视了.  
为了解决这样的问题:  
**1.引入协程.** (协程可以理解成是一个轻量级线程)  
**2.引入线程池.**  
使用线程池的时候，不是说用的时候才创建,而是**提前已经创建好**,放到一个"池子里”这个就和字符串常量池是类似的东西.  
**当我们需要使用线程的时候,直接从池子里取一个线程过来.当我们不需要这个线程的时候,就把这个线程还回池子中**.(此时我们的操作就会比创建销毁线程效率更高)  
如果是真的创建/销毁线程,**涉及到用户态和内核态的切换**(切换到内核态,然后创建出对应的PCB来)  
如果不是真的创建销毁线程,而只是放到池子里，**就相当于全在用户态,就能搞定这个事情**  
所以全在用户态操作,就会更高效.而来回切换到内核态之后,操作就可能很低效.

什么叫用户态和内核态?  
**用户态就是应用程序执行的代码.**  
**内核态就是操作系统内核执行的代码.**  
**一般认为,用户态和内核态之间的切换,是一个开销较大的操作.**

##### 经典的面试题: `ThreadPoolExecutor`的构造方法的参数都是啥意思? #####

![在这里插入图片描述][b75834f184c74306bc27d1b48e4eeeef.jpeg_pic_center]

`ThreadPoolExecutor`里面包含的线程的数量并不是一成不变.它能够根据任务量来自适应.如果任务比较多,就会多创建一些线程.如果任务比较少,就少创建一些线程.  
可以把线程池想象成是一个"公司",公司里面的每个员工，就相当于是一个线程.其中员工分成两类:  
1.正式工:签了劳动合同的,不能随便辞退.  
2.临时工:没签劳动合同,随时可以辞退

`corePoolSize` **核心线程数**.相当于正式员工的数量  
`maximumPoolize`**最大线程数** 相当于是正式员工+临时工  
正式员工允许摸鱼 (**这样的线程及时是空闲，也不会被销毁**)  
临时工,不允许摸鱼(**如果临时工线程摸鱼的时间达到一定的程度了,就会被销毁**)  
那么我们如何确定这两个数的最佳值?如果我们要解决的任务场景,**任务量比较稳定**的就可以设置`corePoolSize`和`maximumPoolSize`尽量接近. (临时工就可以尽量少一些)  
如果要解决的任务场景,**任务量波动比较大**就可以设置`corePoolSize`和`maximumPoolSize`相差更大一些 (临时工就可以多些)

`keepAliveTime` **线程池中空闲线程等待工作的超时时间**(描述临时工摸鱼可以摸多长时间)  
`unit`**时间单位**、**也就是`keepAliveTime`的单位**. 可以是`ms, s, minute`  
这两个参数是计算机在**性能和资源之间做权衡**一种优化  
线程完全不销毁,相当于是**性能最大化.** (创建线程销毁线程的次数最少).但是吃的资源也是**最大化(消耗内存资源**).这个`keepAliveTime`时间越短,其实就是越希望吃的资源能更少  
既然如此,这两个值具体设成多少合适?  
网上有一些说法:CPU是N核,就设定成N,或者是1.5\* N,或者是2\* N(**其实这样不准确**)  
**实际上是和你的机器,以及要执行的任务类型都密切相关.并没有完全固定的数值,而是通过实验的方式来确定比较合适.**

`workQueue` **阻塞队列,用来组织了线程池要执行的任务**.  
`threadFactory`**线程的创建方式**.通过这个参数,来设定不同的线程的创建方式  
`RejectedExecutionHandler handler`. **拒绝策略**  
当任务队列满了的时候,又来了新任务,应该咋办?是丢弃最新的任务?还是丢弃最老的任务?还是阻塞等待?还是抛出异常?  
**这些根据具体的业务场景,来选取具体的拒绝策略.用来处理极端情况的**

##### Executors 创建线程池 #####

由于`ThreadPoolExecutor`使用起来比较复杂,标准库又提供了一组其他的类,相当于对`ThreadPoolExecutor`又进行了一层封装  
**标准库中提供了一个`Executors`这个类.这个类相当于一个“工厂类"**  
通过这个类提供的一组工厂方法,就可以创建出不同风格的线程池实例了.

1.  `newFixedThreadPool`:**创建出一个固定线程数量的线程池**. 相当于只有核心线程(完全没有临时工的版本)
2.  `newCachedThreadPool`:**创建出一个数量可变的线程池**. 相当于创建的全是空闲线程(完全没有正式员工,全是临时工)
3.  `newSingleThreadPool`或者`newSingleThreadExecutor`:**创建出一个只包含一个线程的线程池**. (只是特定场景下使用)
4.  `newScheduleThreadPool`:**能够设定延时时间的线程池**. (插入的任务能够过一会再执行), **相当于进阶版的定时器**.
    
    **`Executors` 本质上是 `ThreadPoolExecutor` 类的封装.**

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    /**
     * Executors 创建线程池
     */
    public class ThreadDemo27 {
        
        public static void main(String[] args) {
        
            //创建一个标准库中的线程池.先创建出一个线程池的实例
            ExecutorService service = Executors.newFixedThreadPool(10);
            //给这个实例里面加一些任务
            for (int i = 0; i < 20; i++) {
        
                service.submit(new Runnable() {
        
                    @Override
                    public void run() {
        
                        System.out.println("hello");
                    }
                });
            }
        }
    }

上面代码中当前线程池里有10个工作线程.往任务队列中加入了20个任务.此时这10个工作线程就会从任务队列中,**先取出10个任务,然后并发执行这些任务**.这些线程谁执行完了,当前的任务,谁就去任务队列中重新取一个新的任务.直到把线程池任务队列中的20个任务都取完了,**此时线程池的工作线程就阻塞等待**(等待新的任务的到来)

##### 当前我们看到了两组线程池的使用风格.一个简单,一个复杂,用哪种更好? #####

解决简单问题,有简单的解法.解决复杂问题,有复杂的解法.如果针对复杂问题，使用简单解法，容易引入一些坑.如果针对简单问题,使用复杂解法,也容易引入一些坑.  
就像阿里的编程规范:明确说了不允许使用`Executors`,使用线程池，要使用这个复杂版本的`ThreadPoolExecutor`.对于阿里这种公司本身有充足的流量(用户量).他们写的每个服务程序,都涉及到“高并发,高可用，大数据".这样的情况复杂的问题或者说对于这样的复杂场景,就需要使用这个复杂版本的线程池.就可以做到一个更加精细的控制.  
但是如果换到其他小公司,这样的情况就不一定适用.因为这个世界上小公司的数目是远远高于大公司的. 这些小公司,根本就没啥高并发,高可用，大数据,所以更推荐使用简单的.

##### 工厂模式 #####

工厂模式也是一种设计模式,和单例模式是并列的关系  
工厂模式存在的意义,**就是在给构造方法填坑**.工厂模式主要是为了创建实例.正经八本的创建实例是通过构造方法.但是构造方法的限制比较多:  
1.构造方法的的名字,必须是固定的(类名)  
2.如果需要多个版本的构造方式，就只能依赖构造方法的重载.  
假设我们有个类Point,表示平面上第一个点.我们希望通过笛卡尔坐标和极坐标,两种方式来构造这个点

class Point{
        
        public Point(double x, double y){
        
            System.out.println("通过笛卡尔坐标构造");
        }
        public Point(double r, double a){
        
            System.out.println("通过极坐标构造");
        }
    }

上面代码中这俩方法的参数个数和类型都一样,无法构成重载这个时候编译不了.而且构造方法的方法名都是固定.光看方法名并不知道咱们是想使用哪种方式构造(**可读性较差**).  
解决这个问题:  
不使用构造方法来构造实例了,而是使用其他的方法来进行构造实例.这样的用来构造实例的方法,就称为"工厂方法"  
工厂方法其实就是普通的方法.**这个工厂方法里面会调用对应的构造方法**，并进行一些初始化操作, 并返回这个对象的实例.

```newFixedThreadPool``newCachedThreadPool``newSingleThreadExecutor``newScheduledThreadPool```在这几个工厂方法里面，调用了`ThreadPoolExecutor`的构造方法,同时把对应的参数进行了传递,并返回这样的`ThreadPoolExecutor`实例

**自己实现一个简单版本的线程池**

实现线程池  
1)核心操作为 `submit`, 将任务加入线程池中  
2)使用 `Worker` 类描述一个工作线程. 使用 `Runnable` 描述一个任务.  
3)使用一个 `BlockingQueue` 组织所有的任务  
4)每个 `worker` 线程要做的事情: 不停的从 `BlockingQueue` 中取任务并执行.  
5)指定一下线程池中的最大线程数 `maxWorkerCount`; 当前线程数超过这个最大值时, 就不再新增线程了.

import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.BlockingQueue;
    import java.util.concurrent.LinkedBlockingQueue;
    
    /**
     * 自己创建一个线程池
     */
    public class ThreadDemo28 {
        
        static class Worker extends Thread{
        
            private BlockingQueue<Runnable> queue = null;
    
            public Worker(BlockingQueue<Runnable> queue){
        
                this.queue = queue;
            }
            @Override
            public void run() {
        
                //这是工作线程,需要从阻塞队列中获取任务并执行
                while (true){
        
                    try {
        
                        Runnable command = queue.take();
                        //run执行任务
                        command.run();
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
            }
        }
        static class ThreadPool{
        
            //包含一个阻塞队列,用来组织任务(不可以在工作线程中创建,那样会导致每次都有一个新的阻塞队列
            private BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>();
    
            //这个list用来存放当前的工作线程
            private List<Thread> workers = new ArrayList<>();
            private static final int MAX_WORKER_COUNT = 10;
    
            //通过这个方法把任务加入到线程池中
            //submit不光可以把任务加到阻塞队列中,同时还可以负责创建线程
            private void submit(Runnable command) throws InterruptedException {
        
                if(workers.size() < MAX_WORKER_COUNT){
        
                    //如果当前工作线程数量不足线程数量的上限,就可以创建新的线程
                    //通过构造方法来获取阻塞队列的元素
                    Worker worker = new Worker(queue);
                    worker.start();
                    workers.add(worker);
                }
                queue.put(command);
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
        
            ThreadPool pool = new ThreadPool();
            for (int i = 0; i < 100; i++) {
        
                pool.submit(new Runnable() {
        
                    @Override
                    public void run() {
        
                        System.out.println("hello");
                    }
                });
            }
        }
    }

[e417efb9dcab4d8596b96b3d0e9936be.jpeg_pic_center]: https://img-blog.csdnimg.cn/e417efb9dcab4d8596b96b3d0e9936be.jpeg#pic_center
[a5be33ae787444abb7be0ee75f44cdb2.jpeg_pic_center]: https://img-blog.csdnimg.cn/a5be33ae787444abb7be0ee75f44cdb2.jpeg#pic_center
[dd18bcf423b84ec1a484f95809772271.jpeg_pic_center]: https://img-blog.csdnimg.cn/dd18bcf423b84ec1a484f95809772271.jpeg#pic_center
[bcaf1d15c8f24860a7446ecf2bbee12e.jpeg_pic_center]: https://img-blog.csdnimg.cn/bcaf1d15c8f24860a7446ecf2bbee12e.jpeg#pic_center
[3d2564db946049ab8680bd76181d93e7.jpeg_pic_center]: https://img-blog.csdnimg.cn/3d2564db946049ab8680bd76181d93e7.jpeg#pic_center
[b75834f184c74306bc27d1b48e4eeeef.jpeg_pic_center]: https://img-blog.csdnimg.cn/b75834f184c74306bc27d1b48e4eeeef.jpeg#pic_center