多线程之线程池

常用接口准备

Executor接口

是线程池的最顶层接口，可以自己实现execute方法，对Runnable对象进行调用。

public class MyExecutor implements Executor{

    public static void main(String[] args) {
        new MyExecutor().execute(()->System.out.println("hello executor"));
    }

    @Override
    public void execute(Runnable command) {
        //new Thread(command).run();
        command.run();
    }
}

ExecutorService接口

在Executor接口的基础上加入了submit(Callable callabe)方法。

Callable接口

Callable接口提供了一个call()方法可以作为线程执行体，但call()方法比run()方法功能更强大:call()方法可以有返回值且call()方法可以声明抛出异常。
Callable接口不是Runnable接口的子接口，所以Callable对象不能直接作为Tread的target，需要使用Future接口来代表Callable接口里call()方法的返回值，并为Future接口提供了一个FutureTask实现类，该实现类实现了Future接口，并实现了Runnable接口，所以可以作为Tread类的target。创建并启动有返回值的线程步骤：

• step1:创建Callable接口的实现类，并实现call()方法；
• step2:使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值；
• step3:使用FutureTask对象作为Tread对象的target创建并启动新线程；
• step4:调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。

public class ThirdThread {
    public static void main(String[] args) {
        ThirdThread rt = new ThirdThread();
        //使用Lambda表达式创建Callable对象，使用FutureTask包装Callable对象
        FutureTask<Integer> task = new FutureTask<>(() -> {
            int i = 0;
            for (; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + " " + i);
            }
            return i;
        });

        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 20) {
                //创建线程，同时命名
                new Thread(task, "有返回值的新线程").start();
            }
        }
        try {
            System.out.println("子线程的返回值为" + task.get());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

注意：FutureTask对象的get方法将导致主线程被阻塞，直到call()方法结束并返回为止，同一个FutureTask只能执行一次。

线程池概述

查看处理器CPU核数：

System.out.println(Runtime.getRuntime().availableProcessors());

线程池用于多线程处理中，它可以根据系统的情况，可以有效控制线程执行的数量，优化运行效果。线程池做的工作主要是控制运行的线程的数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果任务数量超过了最大数量，那么超出数量的任务排队等候，等其它任务执行完毕，再从队列中取出任务来执行。

主要特点为：

• 线程复用
• 控制最大并发数量
• 管理线程

主要优点

• 降低资源消耗，通过重复利用已创建的线程来降低线程创建和销毁造成的消耗。
• 提高相应速度，当任务到达时，任务可以不需要的等到线程创建就能立即执行。
• 提高线程的可管理性，线程是稀缺资源，如果无限制的创建，不仅仅会消耗系统资源，还会降低体统的稳定性，使用线程可以进行统一分配，调优和监控。

线程池的创建

• Executors.newSingleThreadExecutor()：只有一个线程的线程池，因此所有提交的任务是顺序执行。
• Executors.newCachedThreadPool()：线程池里有很多线程需要同时执行，老的可用线程将被新的任务触发重新执行，如果线程超过60秒内没执行，那么将被终止并从池中删除，也可以扩容，一般电脑最多几万个。
• Executors.newFixedThreadPool()：拥有固定线程数的线程池，如果没有任务执行，那么线程会一直等待。

package tjtulong.thread;

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

public class MyThreadPoolDemo {
    public static void main(String[] args) {
        // 一池五线程
        //ExecutorService threadPool = Executors.newFixedThreadPool(5);
        // 一池一线程
        //ExecutorService threadPool = Executors.newSingleThreadExecutor();
        // 一池N线程
        ExecutorService threadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 6; i++) {
            service.execute(() -> {
                try {
                    TimeUnit.MILLISECONDS.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            });
        }
        System.out.println(service);
        //java.util.concurrent.ThreadPoolExecutor@3b9a45b3[Running, pool size = 5, active threads = 5, queued tasks = 1, completed tasks = 0]

        service.shutdown();
        System.out.println(service.isTerminated());//是否执行完false
        System.out.println(service.isShutdown());//是否关闭true
        System.out.println(service);
        //java.util.concurrent.ThreadPoolExecutor@3b9a45b3[Shutting down, pool size = 5, active threads = 5, queued tasks = 1, completed tasks = 0]

        TimeUnit.SECONDS.sleep(5);
        System.out.println(service.isTerminated());//true
        System.out.println(service.isShutdown());//true
        System.out.println(service);
        //java.util.concurrent.ThreadPoolExecutor@3b9a45b3[Terminated, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 6]
    }
}

线程池参数及原理

七个参数

参数	作用
corePoolSize	核心线程池大小
maximumPoolSize	最大线程池大小
keepAliveTime	线程池中超过 corePoolSize 数目的空闲线程最大存活时间
TimeUnit	keepAliveTime时间单位
workQueue	阻塞任务队列
threadFactory	新建线程工厂
RejectedExecutionHandler	当提交任务数超过 maxmumPoolSize+workQueue 之和时，任务会交给RejectedExecutionHandler 来处理

底层原理

核心在于corePoolSize，maximumPoolSize，workQueue之间关系。

1. 当线程池小于corePoolSize时，新提交任务将创建一个新线程执行任务，即使此时线程池中存在空闲线程。
2. 当线程池达到corePoolSize时，新提交任务将被放入workQueue中，等待线程池中任务调度执行。
3. 当workQueue已满，且maximumPoolSize大于corePoolSize时，新提交任务会创建新线程执行任务。
4. 当提交任务数超过maximumPoolSize时，新提交任务由RejectedExecutionHandler处理。
5. 当线程池中超过corePoolSize线程，空闲时间达到keepAliveTime时，关闭空闲线程 。
6. 当设置allowCoreThreadTimeOut(true) 时，线程池中corePoolSize线程空闲时间达到 keepAliveTime 也将关闭。

线程池具体实现：

可参考：https://blog.csdn.net/z55887/article/details/79060070

拒绝策略

等待队列已经满了，再也塞不下新的任务，同时线程池中的线程数达到了最大线程数，无法继续为新任务服务，这时需要使用拒绝策略。

• AbortPolicy：处理程序遭到拒绝将抛出运行时 RejectedExecutionException 。
• CallerRunsPolicy：线程调用运行该任务的 execute 本身。此策略提供简单的反馈控制机制，能够减缓新任务的提交速度。
• DiscardPolicy：不能执行的任务将被删除。
• DiscardOldestPolicy：如果执行程序尚未关闭，则位于工作队列头部的任务将被删除，然后重试执行程序（如果再次失败，则重复此过程）。

自定义线程池

阿里巴巴手册中规定：

【强制】线程资源必须通过线程池提供，不允许在应用中自行显式创建线程。

【强制】线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，避免资源耗尽。

Java中的BlockingQueue主要有两种实现，分别是ArrayBlockingQueue 和 LinkedBlockingQueue。

ArrayBlockingQueue是一个用数组实现的有界阻塞队列，必须设置容量。

LinkedBlockingQueue是一个用链表实现的有界阻塞队列，容量可以选择进行设置，不设置的话，将是一个无边界的阻塞队列，最大长度为Integer.MAX_VALUE。

这里的问题就出在：不设置的话，将是一个无边界的阻塞队列，最大长度为Integer.MAX_VALUE。也就是说，如果我们不设置LinkedBlockingQueue的容量的话，其默认容量将会是Integer.MAX_VALUE。

而newFixedThreadPool中创建LinkedBlockingQueue时，并未指定容量。此时，LinkedBlockingQueue就是一个无边界队列，对于一个无边界队列来说，是可以不断的向队列中加入任务的，这种情况下就有可能因为任务过多而导致内存溢出问题。

上面提到的问题主要体现在newFixedThreadPool和newSingleThreadExecutor两个工厂方法上，并不是说newCachedThreadPool和newScheduledThreadPool这两个方法就安全了，这两种方式创建的最大线程数可能是Integer.MAX_VALUE，而创建这么多线程，必然就有可能导致OOM。

因此在实际使用中，要自定义线程池：

public class ThreadPoolExecutorDemo {

    public static void main(String[] args) {
        Executor executor = new ThreadPoolExecutor(2, 3, 1L, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(5), 
                Executors.defaultThreadFactory(), 
                new ThreadPoolExecutor.DiscardPolicy());
    }
}

合理配置线程数

• CPU 密集型
  • CPU 密集的意思是该任务需要大量的运算，而没有阻塞，CPU 一直全速运行。
  • CPU 密集型任务尽可能的少的线程数量，一般为 CPU 核数 + 1 个线程的线程池。
• IO 密集型
  • 由于 IO 密集型任务线程并不是一直在执行任务，可以多分配一点线程数，如 CPU * 2 。
  • 也可以使用公式：CPU 核数 / (1 - 阻塞系数)；其中阻塞系数在 0.8 ～ 0.9 之间。

特殊线程池

ScheduledPool

以固定的频率执行任务

public class ScheduledPool {
    public static void main(String[] args) {
        ScheduledExecutorService service = Executors.newScheduledThreadPool(4);
        service.scheduleAtFixedRate(()->{
            try {
                TimeUnit.MILLISECONDS.sleep(new Random().nextInt(1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName());
        }, 0, 500, TimeUnit.MILLISECONDS);
        // 500 表示每隔0.5秒执行一次
    }
}

其底层依然是ThreadPoolExecutor，阻塞队列为DelayedWordQueue（实现延时执行）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iLs1JRKH-1584512233961)(C:\Users\TJtulong\AppData\Roaming\Typora\typora-user-images\1584457969600.png)]

ForkJoinPool

Fork/Join框架就是在必要的情况下，将一个大任务进行拆分(fork)成若干个小任务(拆到不可再拆时)，再将一个个的小任务运算的结果进行join汇总。

一般使用RecursiveTask(有返回值)和RecursiveAction(无返回值)实现类，类似递归。

案例：计算1000000个整数的和

public class ForkJoinPoolDemo {
    static int[] nums = new int[1000000];
    static final int MAX_NUM = 50000;
    static Random r = new Random();

    static {
        for(int i=0; i<nums.length; i++) {
            nums[i] = r.nextInt(100);
        }
        System.out.println(Arrays.stream(nums).sum()); //stream api
    }

    static class AddTask extends RecursiveTask<Long> {

        private static final long serialVersionUID = 1L;
        int start, end;

        AddTask(int s, int e) {
            start = s;
            end = e;
        }

        @Override
        protected Long compute() {

            if(end-start <= MAX_NUM) {
                long sum = 0L;
                for(int i=start; i<end; i++) sum += nums[i];
                return sum;
            }

            int middle = start + (end-start)/2;

            AddTask subTask1 = new AddTask(start, middle);
            AddTask subTask2 = new AddTask(middle, end);
            subTask1.fork();
            subTask2.fork();

            return subTask1.join() + subTask2.join();
        }

    }

    public static void main(String[] args) throws IOException {
        ForkJoinPool fjp = new ForkJoinPool();
        AddTask task = new AddTask(0, nums.length);
        fjp.execute(task);
        long result = task.join();
        System.out.println(result);

        //System.in.read();
    }
}

注：ForkJoinPool不是源于ThreadPoolExecutor

WorkStealingPool

工作窃取线程池：线程池中每隔线程都维护一个任务列表，当自身的任务列表执行完成后，会执行别的线程的任务列表。本质是ForkJoinPool线程池，所有的线程都是精灵线程。

假设共有三个线程A、B、C同时执行。当A、B线程池尚未处理任务结束，而C已经处理完毕，则C线程会从A或者B中窃取任务执行，这就叫工作窃取。假如A线程中的队列里面分配了5个任务，而B线程的队列中分配了1个任务，当B线程执行完任务后，它会主动的去A线程中窃取其他的任务进行执行。

public class WorkStealingPoolDemo {
    public static void main(String[] args) throws IOException {
        ExecutorService service = Executors.newWorkStealingPool();
        System.out.println(Runtime.getRuntime().availableProcessors());

        service.execute(new R(1000)); //该线程先执行完
        service.execute(new R(2000));
        service.execute(new R(2000));
        service.execute(new R(2000)); //daemon
        service.execute(new R(2000));

        //由于产生的是精灵线程（守护线程、后台线程），主线程不阻塞的话，看不到输出
        System.in.read();
    }

    static class R implements Runnable {
        int time;
        R(int t) {
            this.time = t;
        }

        @Override
        public void run() {
            try {
                TimeUnit.MILLISECONDS.sleep(time);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(time  + " " + Thread.currentThread().getName());
        }
    }
}

4
1000 ForkJoinPool-1-worker-1
2000 ForkJoinPool-1-worker-2
2000 ForkJoinPool-1-worker-3
2000 ForkJoinPool-1-worker-0
2000 ForkJoinPool-1-worker-1 //窃取了其它线程的任务

由其构造方法可见本质是ForkJoinPool，且默认线程数为CPU核数。

public static ExecutorService newWorkStealingPool() {
    return new ForkJoinPool
        (Runtime.getRuntime().availableProcessors(),
         ForkJoinPool.defaultForkJoinWorkerThreadFactory,
         null, true);
}

应用案例

NASA并行计算

任务：计算1-200000之间有多少个质数。

public class ParallelComputing {
    public static void main(String[] args) throws Exception {
        long start = System.currentTimeMillis();
        getPrime(1, 200000);
        long end = System.currentTimeMillis();
        System.out.println(end - start); //2453ms

        final int cpuCoreNum = 4;

        ExecutorService service = Executors.newFixedThreadPool(cpuCoreNum);

        MyTask t1 = new MyTask(1, 80000);
        MyTask t2 = new MyTask(80001, 130000);
        MyTask t3 = new MyTask(130001, 170000);
        MyTask t4 = new MyTask(170001, 200000);

        Future<List<Integer>> f1 = service.submit(t1);
        Future<List<Integer>> f2 = service.submit(t2);
        Future<List<Integer>> f3 = service.submit(t3);
        Future<List<Integer>> f4 = service.submit(t4);

        start = System.currentTimeMillis();
        f1.get();
        f2.get();
        f3.get();
        f4.get();
        end = System.currentTimeMillis();
        System.out.println(end - start);//5632ms
    }

    static class MyTask implements Callable<List<Integer>> {
        int startPos, endPos;

        MyTask(int s, int e) {
            this.startPos = s;
            this.endPos = e;
        }

        @Override
        public List<Integer> call() throws Exception {
            List<Integer> r = getPrime(startPos, endPos);
            return r;
        }
    }
    // 判断质数
    static boolean isPrime(int num) {
        for(int i=2; i<=num/2; i++) {
            if(num % i == 0) return false;
        }
        return true;
    }

    static List<Integer> getPrime(int start, int end) {
        List<Integer> results = new ArrayList<>();
        for(int i=start; i<=end; i++) {
            if(isPrime(i)) results.add(i);
        }
        return results;
    }
}

从MongoDB向MySQL同步数据

爬虫团队每天从QQ音乐爬取音乐的热度，将【音乐名称，歌手，热度值，日期】作为数据放入MongoDB中。MySQL中存有可用音乐信息，需求为每天定时根据MongoDB数据更新MySQL数据库中的音乐热度。

对于每一条MySQL数据，首先要根据音乐名称+歌手+今日日期去MongoDB找到对应的一条文档，然后拿到热度值update到MySQL中。由于由大量的IO操作，因此如果采用单线程十分耗时，十万条音乐数据需要6小时。考虑采用线程池处理，根据服务器CPU核数*2配置线程池大小N，将MySQL表的十万条数据平均分为N份，每个线程去处理1/N的数据，运行完成时间变为25分钟。

Executor executor = new ThreadPoolExecutor(16, 16, 0, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(5), 
                Executors.defaultThreadFactory(), 
                new ThreadPoolExecutor.DiscardPolicy());

CDN分发

需求：推荐团队将推荐的短视频信息放入一个small_video_corpus_info.txt文件中，从文件中读取每行记录，提取每行的短视频ID，根据视频ID去奇谱（公司的一个服务）HTTP请求到视频的Mp4Url（地址），将所有的Mp4Url，写入CDN_FILE_PATH文件，供CDN团队分发。

采用线程池，每十条视频为一组放入List中形成一个任务，放入线程池中执行，多个线程写入一个LinkedBlockingQueue阻塞队列，再由一个线程去阻塞队列中读取数据，写入分发文件中。