线程池【重点】

线程池概述

什么是线程池？

• 线程池就是一个可以复用线程的技术（一个线程反复使用，比如：一个线程处理完一个用户再去处理另一个用户）。

不使用线程池的问题

• 如果用户每发起一个请求，后台就创建一个新线程来处理，下次新任务来了又要创建新线程，而创建新线程的开销是很大的，因为线程是个对象，是要占内存的，而且还要竞争CPU来执行自己（程序是由CPU负责调度的），这样会严重影响系统的性能。

线程池实现的API、参数说明

谁代表线程池？

• JDK 5.0起提供了代表线程池的接口：ExecutorService

如何得到线程池对象

• 方式一：使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象
  
• 方式二：使用Executors（线程池的工具类）调用方法返回不同特点的线程池对象

ThreadPoolExecutor构造器的参数说明

线程池常见面试题

临时线程什么时候创建啊？

• 新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程。

什么时候会开始拒绝任务？

• 核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始任务拒绝。

1、谁代表线程池？

• ExecutorService接口

2、ThreadPoolExecutor实现线程池对象的七个参数是什么意思

• 使用线程池的实现类ThreadPoolExecutor

线程池处理Runnable任务

ThreadPoolExecutor创建线程池对象示例

ExecutorService的常用方法

新任务拒绝策略

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            //得到线程池中哪个线程处理的
            System.out.println(Thread.currentThread().getName()+"输出了hello，world===>"+i);
        }
        try {
            System.out.println(Thread.currentThread().getName()+"本任务与线程绑定了，线程进入休眠~~~");
            Thread.sleep(1000000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import java.util.concurrent.*;
/**
 * 目标：自定义线程池对象，并测试其特性
 */
public class ThreadPoolDemo1 {
    public static void main(String[] args) {
         /*
     public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)
    */
        //1、创建线程池对象(临时工：5-3：两个，空闲线程没事情干只活6秒)
        ExecutorService pool = new ThreadPoolExecutor(3,5,
                6, TimeUnit.SECONDS,new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

        //2、给任务，线程池处理（线程池只接Runnable和Callable任务）
        Runnable target = new MyRunnable();
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);

        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);

        //创建临时线程（招人了）
        pool.execute(target);
        pool.execute(target);

        //池满了，不创建线程了，拒绝（抛出异常了）
        pool.execute(target);

        //关闭线程池(开发中一般不会使用)
        //pool.shutdownNow();//立即关闭，即使任务没有完成，所以它会丢失任务的
        pool.shutdown();//会等待任务全部执行完毕之后再关闭
    }
}

线程池如何处理Runnable任务

• 使用ExecutorService的方法：
• void execute(Runnable target)

线程池处理Callable任务

ExecutorService的常用方法

线程池如何处理Callable任务，并得到任务执行完后返回的结果

• 使用ExecutorService的方法：
• Future submit(Callable command)

/**
 * 1、定义一个任务类，实现Callable接口,指定一个泛型（返回结果:任务执行完返回字符串）
 * 应该申明线程任务结束完毕后的结果的数据类型
 */
public class MyCallable implements Callable<String> {
    /*2、重写call方法,看到返回值类型已经变成String了*/
    private int n;

    /*在创建对象的时候，将n创造出来*/
    public MyCallable(int n) {
        this.n = n;
    }

    @Override
    public String call() throws Exception {
        //重写call方法（任务方法），比如计算1-n的和
        int sum = 0;
        for (int i = 0; i < n; i++) {
            sum += i;
        }
        return Thread.currentThread().getName()+"线程计算1-"+n + "的计算结果为：" + sum;
    }
}

/**
 * 目标：自定义线程池对象，并测试其特性
 */
public class ThreadPoolDemo2 {
    public static void main(String[] args) throws Exception {
         /*
     public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)
    */
        //1、创建线程池对象(临时工：5-3：两个，空闲线程没事情干只活6秒)
        ExecutorService pool = new ThreadPoolExecutor(3,5,
                6, TimeUnit.SECONDS,new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

//2、给任务，线程池处理（直接把MyCallable任务对象new完之后直接扔到池子中去排队,池子里边的线程会调用任务对象的call方法，执行完把结果给它）
        //返回未来任务对象，通过它的get方法拿结果（这里提交了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));

       /* String rs1 = f1.get();调get得到任务中call方法的结果
        String rs2 = f2.get();
        String rs3 = f3.get();
        String rs4 = f4.get();*/
        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());
    }
}

Executors工具类实现线程池

Executors得到线程池对象的常用方法

• Executors：线程池的工具类通过调用方法返回不同类型的线程池对象。

注意：Executors的底层其实也是基于线程池的实现类ThreadPoolExecutor创建线程池对象的。

Executors使用可能存在的陷阱

• 大型并发系统环境中使用Executors如果不注意可能会出现系统风险。
  
  

Executors工具类底层是基于什么方式实现的线程池对象？

• 线程池ExecutorService的实现类：ThreadPoolExecutor

Executors是否适合做大型互联网场景的线程池方案？

• 不合适，要么任务过多导致内存溢出，要么线程过多导致内存溢出。
• 建议使用ThreadPoolExecutor来指定线程池参数，这样可以明确线程池的运行规则，规避资源耗尽的风险。