实现线程池

1.线程池是什么？

线程池，字面意思来说，有点类似与我们的字符串常量池，数据库连接池等等。

1.1 为啥要引入线程池这一概念呢？？

🍃这得从引入线程说起，，

🍃进程本身已经能做到 并发编程了，为啥还要有线程？？进程太重量了，创建和销毁成本都比较高（需要申请、释放资源），而线程就是针对上述问题的优化（同一个进程中的线程共用同一组系统资源）

🍃虽然如此，但是在更频繁的创建、释放资源的场景下，线程也有点扛不住了！！

所以，进一步优化，就引入了线程池。线程池存在的目的，就是为了让程序猿不必创建新的线程，直接使用已有的线程完成想要进行的工作即可！！

🍁【线程池解决问题的思路】

把线程创建好了之后，放到池子里，需要使用线程，就直接从池子里取，而不是通过系统来创建。当线程用完了，又放回池子里，而不是通过系统来销毁！！

1.2 为什么把线程放到池子里，从池子里取线程就要比从系统这里创建线程效率高呢？？

🍃1.从池子里取，是纯用户态操作。

🍃2.通过系统来创建，涉及到内核操作。

而我们通常认为，牵扯到内核态操作，就要比纯用户态的操作更低效！！结合下图场景理解

 2.标准库中的线程池

🍃1.使用 Executors.newFixedThreadPool(10) 能创建出固定包含 10 个线程的线程池.

🍃2.返回值类型为 ExecutorService

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

public static void main(String[] args) {
    ExecutorService threadPool = Executors.newFixedThreadPool(10);
    for(int i = 0; i < 100; i++) {
        threadPool.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello");
            }
        });
    }
}

ExecutorService threadPool = Executors.newFixedThreadPool(10);

class Point {
    // 笛卡尔坐标系，构造点
    public Point(double x, double y) { };
    // 使用极坐标系，构造点
    public Point(double r, double a) { };
 
    // Error : 编译错误
}

class Point {
    // 笛卡尔坐标系，构造点
    public static Point makePointByXY(double x, double y) {
        Point point = new Point();
        point.setX(x);
        point.setY(y);
        return point;
    }
    // 极坐标系，构造点
    public static Point makePointByRA(double r, double a) {
        Point point = new Point();
        point.setR(r);
        point.setA(a);
        return point;
    }
}

 Executors 里面的各种工厂方法，其实都是针对 ThreadPoolExecutor 这个类进行了 new 并且闯入不同风格的参数，来达到构造不同种类线程池的目标！！

3.实现线程池

class MyThreadPool {
    // 这个队列就是 "任务队列" 把当前线程要完成的任务都放入到这个队列中
    // 再由线程池内部的工作线程负责完成它们！！
    private BlockingQueue queue = new LinkedBlockingQueue<>();
 
    // 核心方法，往线程池里插入任务
    public void submit(Runnable runnable) {
        try {
            queue.put(runnable);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    // n : 设定线程池里有几个线程
    public MyThreadPool(int n) {
        // 构造方法中就需要创建一些线程，让这些线程负责执行上述插入的任务
        for(int i = 0; i < n; i++) {
            Thread t = new Thread(() -> {
                while(!Thread.currentThread().isInterrupted()) {
                    try {
                        // 取出任务，直接执行
                        Runnable runnable = queue.take();
                        runnable.run();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            t.start();
        }
    }
}
public class TestDemo3 {
    public static void main(String[] args) {
        // 10 个线程一起执行 100 个任务
        MyThreadPool myThreadPool = new MyThreadPool(10);
        for(int i = 0; i < 100; i++) {
            myThreadPool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("hello");
                }
            });
        }
    }
}

线程池的实现相比于定时器，要简单太多了！！ 

🍁【基本步骤】

🍃1.核心操作为 submit，将任务加入线程池中；

🍃2.使用一个 BlockingQueue 组织所有的任务；

🍃3.每个线程，不停的从 BlockingQueue 中取任务并执行即可。

本篇博客就到这里了，谢谢观看！！