多线程：线程池

线程池

认识线程池

什么是线程池

线程池就是一个可以复用线程的技术。

不使用线程池的问题

用户每发起一个请求，后台就需要创建一个新线程来处理，下次新任务来了肯定又要创建新线程处理的，而创建新线程的开销是很大的，并且请求过多时，肯定会产生大量的线程出来，这样会严重影响系统的性能。

如何创建线程池

谁代表线程池

JDK5.0起提供了代表线程池的接口：ExecutorService。

如何得到线程池对象

方式一：使用ExecutorService的实现类ThreadPoolExecutor自创建一个现线程池对象。

方式二：使用Executors（线程池的工具类）调用方法返回不同特点的线程池对象。

ThreadPoolExecutor构造器

参数一：corePoolSize：指定线程池的核心线程的数量
参数二：maximumPoolSize：指定线程池的最大线程数量
参数三：keepAliveTime：指定临时线程的存货时间
参数四：unit：指定临时线程存货的时间单位（秒、分、时、天）
参数五：workQueue：指定线程池的任务队列
参数六：threadFactory：指定线程池的线程工厂
参数七：handler：指定现场尺寸的任务拒绝策略（线程都在忙，任务队列也满了的时候，新任务来了该怎么处理）

线程池的注意事项

临时线程什么时候创建？

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

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

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

线程池处理Runnable任务

ExecutorService的常用方法

方法名称	说明
void execute（Runnable command）	执行Runnable任务
Future<T> submit（Callable<T> task）	执行Callable任务，返回未来任务对象，用于获取线程返回的结果
void shutdown（）	等全部任务执行完毕后，再关闭线程池
List<Runnable> shutdownNow（）	立即关闭线程池，停止正在执行的任务，并返回队列中未执行的任务

ThreadPoolTest1类

import java.util.concurrent.*;

public class ThreadPoolTest1 {
    public static void main(String[] args) {
        // 通过ThreadPoolExecutor创建一个线程池对象
        ExecutorService pool = new ThreadPoolExecutor(3,5,8,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(4),                    Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());

        Runnable target = new MyRunnable();
        pool.execute(target); //线程会自动创建一个新线程，自动处理这个任务，自动执行的
        pool.execute(target); //线程会自动创建一个新线程，自动处理这个任务，自动执行的
        pool.execute(target); //线程会自动创建一个新线程，自动处理这个任务，自动执行的
        pool.execute(target); //复用前面的核心线程
        pool.execute(target); //复用前面的核心线程

        pool.shutdown(); //等着线程池的任务全部执行完毕后，再关闭线程
        //pool.shutdownNow(); //立即关闭线程池，不管任务是否执行完毕
    }
}

MyRunnable类

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

新任务拒绝策略

策略	详解
ThreadPoolExecutor.AbortPolicy	丢弃任务并抛出RejectedExecutionException异常。是默认的策略
ThreadPoolExecutor.DiscardPolicy	丢弃任务，但是不抛出异常，这是不推荐的做法
ThreadPoolExecutor.DiscardOldestPolicy	抛弃队列中等待最久的任务，然后把当前任务加入队列中
ThreadPoolExecutor.CallerRunsPolicy	由主线负责调用任务的run（）方法从而绕过线程池直接执行

线程池处理Callable任务

ExecutorService的常用方法

方法名称	说明
void execute（Runnable command）	执行任务/命令，没有返回值，一般用来执行Runnable任务
Future<T> submit（Callable<T> task）	执行任务，返回未来任务对象获取线程结果，一般拿来执行Callable任务
void shutdown（）	等待执行完毕后关闭线程池
List<Runnable> shutdownNow（）	立即关闭，停止正在执行的任务，并返回队列中未执行的任务

ThreadPoolTest2类

import java.util.concurrent.*;

public class ThreadTest2 {
    public static void main(String[] args) throws Exception {
        // 通过ThreadPollExecutor创建一个线程池对象
        ExecutorService pool = new ThreadPoolExecutor(3,5,8,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.CallerRunsPolicy());

        // 使用线程处理Callable任务
        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));

        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());
    }
}

MyCallable类

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {
    private int n;
    public MyCallable(int n) {
        this.n = n;
    }

    // 重写call方法
    @Override
    public String call() throws Exception {
        // 描述线程的任务，返回线程执行返回后的结果
        // 需求：求1~n的和返回
        int sum = 0;
        for (int i = 1; i < n; i++) {
            sum += i;
        }
        return Thread.currentThread().getName() + "求出了1~" + n + "的和是：" + sum;
    }
}

Executors工具类事项线程池

Executors

是一个线程池的工具类，提供了很多静态方法用于返回不同特点的线程池对象。

方法名称	说明
public static ExecutorService newFixedThreadPoll（int nThreads）	创建固定线程数量的线程池，如果某个线程因为执行异常而结束，那么线程池会补充一个新的线程替代它
public static ExecutorService newSingleThreadExecutor（）	创建只有一个线程的线程池对象，如果该线程出现异常而结束，那么线程池会补充一个新线程
public static ExecutorService newCachedThreadPoll（）	线程数量随着任务增加而增加，如果线程任务执行完毕且空闲了60s则会被回收掉
public static ScheduledExecutorService newScheduledThreadPoll（int nThreads）	创建一个线程池，可以实现在给定的延迟后允许任务，或者定期执行任务

注意：这些方法的底层，都是通过线程池的实现类ThreadPoolExecutor创建的线程池对象。

Executors使用可能存在的陷阱

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

其他线程知识：并发、并行、线程的生命周期

进程

正在运行的程序（软件）就是一个独立的进程。
线程是属于进程的，一个进程中可以同时运行很多个线程。
进程中的多个线程其实是并发和并行执行的。

并发的含义

进程中的线程是由CPU负责调度执行的，但CPU能同时处理线程的数量有限，为了保证全部线程都能往前执行，CPU会轮询为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发。

并行的理解

在同一时刻上，同时有多个线程在被CPU调度执行。

线程的生命周期

也就是线程从生到死的过程中，经历的各种状态及状态转换。
理解线程这些状态有利于提升并发编程的理解能力。

Java线程的状态

Java总共定义了6种状态
6种状态都定义在Thread类的内部枚举类中。

线程的6种状态互相转换

线程的6种状态总结

线程状态	说明
NEW（新建）	线程刚被创建，但是并未启动
Runnable（可运行）	线程已经调用了start（），等待CPU调度
Blocked（锁阻塞）	线程在执行的时候未竞争到锁对象，则该线程进入Blocked状态
Waiting（无限等待）	一个线程进入Waiting状态，另一个线程调用notify或者notifyAll方法才能够唤醒
Timed Waiting（计时等待）	同waiting状态，有几个方法（sleep，wait）有超时参数，调用他们将进入Timed Waiting状态
Teminated（被终止）	因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡