多线程：线程池

线程池

认识线程池

什么是线程池

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

不使用线程池的问题

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

如何创建线程池 

谁代表线程池

• 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方法而死亡