Java多线程案例【线程池】

一.线程池是什么

1.1线程池的概述

线程池和字符串常量池一样，都是为了提高程序运行效率而提出的效率，程序中每创建一个线程就会把该线程加载到一个“池子”中去，其实这个池子就是List，当程序下次需要调用该线程的时候，可以直接从线程池中去取，而不用花费更大的力气去重新创建和销毁线程，从而使程序的运行效率提高，线程池也是管理线程的方式之一,因为使用线程池调度线程是在用户态实现的，而线程的创建是基于内核态实现的**。为什么说用户态比内核态更加高效呢？因为你将任务交给内核态时，内核态不仅仅只去完成你交给它的任务，大概率还会伴随完成其他的任务，而你将任务交给用户态时，用户态只去完成你所交代的任务，所以综上所述，用户态效率更高**

举个例子,想象这么一个场景：
在学校附近新开了一家快递店，老板很精明，想到一个与众不同的办法来经营。店里没有雇人，而是每次有业务来了，就现场找一名同学过来把快递送了，然后解雇同学。这个类比我们平时来一个任务，起一个线程进行处理的模式。很快老板发现问题来了，每次招聘 + 解雇同学的成本还是非常高的。老板还是很善于变通的，知道了为什么大家都要雇人了，所以指定了一个指标，公司业务人员会扩张到 3 个人，但还是随着业务逐步雇人。于是再有业务来了，老板就看，如果现在公司还没 3 个人，就雇一个人去送快递，否则只是把业务放到一个本本上，等着 3 个快递人员空闲的时候去处理。这个就是我们要带出的线程池的模式

线程池最大的好处就是减少每次启动、销毁线程的损耗

二.线程池的使用

2.1线程池的构造方法

使用 Executors.newFixedThreadPool(n) 能创建出固定包含 n 个线程的线程池
返回值类型为 ExecutorService
通过 ExecutorService.submit submit方法可以注册一个任务到线程池中

Executors 创建线程池的几种方式:

项目	Value
newFixedThreadPool	创建固定线程数的线程池
newCachedThreadPool	创建线程数目动态增长的线程池.
newSingleThreadExecutor	创建只包含单个线程的线程池.
newScheduledThreadPool	设定 延迟时间后执行命令，或者定期执行命令. 是进阶版的 Timer.

Executors 本质上是 ThreadPoolExecutor 类的封装

2.2线程池的使用

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

public class Test {
    public static void main(String[] args) {
        // 创建一个固定线程数目的线程池. 参数指定了线程个数
        ExecutorService pool = Executors.newFixedThreadPool(10);
        // 创建一个自动扩容的线程池. 会根据任务量来自动进行扩容
        // Executors.newCachedThreadPool();
        // 创建一个只有一个线程的线程池.
        // Executors.newSingleThreadExecutor();
        // 创建一个带有定时器功能的线程池. 类似于 Timer
        // Executors.newScheduledThreadPool();
        for (int i = 0; i < 100; i++) {
            pool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("hello threadpool");
                }
            });
        }
    }
}

三.线程池的实现

3.1线程池的构造

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

class MyThreadPool {
    // 1. 描述一个任务. 直接使用 Runnable, 不需要额外创建类了.
    // 2. 使用一个数据结构来组织若干个任务.
    private BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>();
    // 3. 描述一个线程, 工作线程的功能就是从任务队列中取任务并执行.
    static class Worker extends Thread {
        // 当前线程池中有若干个 Worker 线程~~ 这些 线程内部 都持有了上述的任务队列.
        private BlockingQueue<Runnable> queue = null;
        public Worker(BlockingQueue<Runnable> queue) {
            this.queue = queue;
        }

        @Override
        public void run() {
            // 就需要能够拿到上面的队列!!
            while (true) {
                try {
                    // 循环的去获取任务队列中的任务.
                    // 这里如果队列为空, 就直接阻塞. 如果队列非空, 就获取到里面的内容~~
                    Runnable runnable = queue.take();
                    // 获取到之后, 就执行任务.
                    runnable.run();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    // 4. 创建一个数据结构来组织若干个线程.
    private List<Thread> workers = new ArrayList<>();

    public MyThreadPool(int n) {
        // 在构造方法中, 创建出若干个线程, 放到上述的数组中.
        for (int i = 0; i < n; i++) {
            Worker worker = new Worker(queue);
            worker.start();
            workers.add(worker);
        }
    }

    // 5. 创建一个方法, 能够允许程序猿来放任务到线程池中.
    public void submit(Runnable runnable) {
        try {
            queue.put(runnable);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

3.2构造线程池的使用

public class Test2 {
    private static int add = 0;
    public static void main(String[] args) throws InterruptedException {
        MyThreadPool pool = new MyThreadPool(10);
        for (int i = 0; i < 100; i++) {
            pool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("开始执行"+add);
                }
            });
            add++;
            Thread.sleep(500);
        }
    }
}