多线程：线程池

认识线程池

什么是线程池?

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

不使用线程池的问题：

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

线程池的工作原理：线程池可以控制线程的数量，然后重复的去利用这些线程来处理任务，同时也可以控制任务的数量，把这些任务暂时的缓存起来，让线程来处理他们；由于线程池可以控制线程的数量也可以控制任务的数量，因此他不会因为这些线程过多，或者任务过多而导致把系统资源耗尽引起系统瘫痪的风险。整体来看可以提高系统的工作性能。

如何创建线程池?

谁代表线程池?

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

如何得到线程池对象?

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

ThreadPoolExecutor构造器

• 参数一:corePoolSize:指定线程池的核心线程的数量。                                        正式工:3
• 参数二:maximumPoolSize:指定线程池的最大线程数量。              最大员工数:5临时工:2
• 参数三:keepAliveTime:指定临时线程的存活时间。                       临时工空闲多久被开除
• 参数四:unit:指定临时线程存活的时间单位(秒、分、时、天)
• 参数五:workQueue:指定线程池的任务队列。                                           客人排队的地方
• 参数六:threadFactory:指定线程池的线程工厂。                                 负责招聘员工的(hr)
• 参数七:handler:指定线程池的任务拒绝策略( 线程都在忙，任务队列也满了的时候，新任务来了该怎么处理)                                                                                     忙不过来咋办?

/**
  * public ThreadPoolExecutor(int corePoolSize,
  *                               int maximumPoolSize,
  *                               long keepAliveTime,
  *                               TimeUnit unit,
  *                               BlockingQueue<Runnable> workQueue,
  *                               ThreadFactory threadFactory,
  *                               RejectedExecutionHandler handler)
  */
        ExecutorService pool = new ThreadPoolExecutor(3,3,8,
                TimeUnit.SECONDS,new ArrayBlockingQueue<>(4),Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

线程池的注意事项
1.临时线程什么时候创建?
新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程。
2.什么时候会开始拒绝新任务?
核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始拒绝任务。

线程池处理Runnable任务

ExecutorService的常用方法

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        //任务是干啥的
        System.out.println(Thread.currentThread().getName()+"输出666");
        try {
            Thread.sleep(Integer.MAX_VALUE);//让休眠时间是最大的整型值，线程就会一直被任务拽着
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

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.execute(target);

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

新任务拒绝策略

线程池处理Callable任务

ExecutorService的常用方法

import java.util.concurrent.Callable;

//实现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;
    }
}

import java.util.concurrent.*;

public class ThreadPoolTest2 {
    public static void main(String[] args) throws Exception {
        //1.通过ThreadPoolExecutor创建一个线程池对象
        ExecutorService pool = new ThreadPoolExecutor(3,3,8,
                TimeUnit.SECONDS,new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.CallerRunsPolicy());
        //2.使用线程处理Callable任务
        //Callable myCallable = new MyCallable(100);
        //有了Callable对象之后，也可以直接把他交给线程池来处理
        Future<String> f1 = pool.submit(new MyCallable(100));//把Callable对象交给submit方法，他其实把任务给了线程池，线程池会创建线程处理Callable任务
        //调用的还是Callable任务里面的call方法执行的，并且还会返回一个未来任务对象给我们，用f1来接，到时候会通过未来任务对象，调get方法获取这个线程执行完毕后的任务的结果
        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));
        //接下来就可以通过未来任务对象获取线程执行完毕的结果
        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());

    }
}
package com.itheima.d8_thread_pool;

import java.util.concurrent.*;

public class ThreadPoolTest2 {
    public static void main(String[] args) throws Exception {
        //1.通过ThreadPoolExecutor创建一个线程池对象
        ExecutorService pool = new ThreadPoolExecutor(3,3,8,
                TimeUnit.SECONDS,new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.CallerRunsPolicy());
        //2.使用线程处理Callable任务
        //Callable myCallable = new MyCallable(100);
        //有了Callable对象之后，也可以直接把他交给线程池来处理
        Future<String> f1 = pool.submit(new MyCallable(100));//把Callable对象交给submit方法，他其实把任务给了线程池，线程池会创建线程处理Callable任务
        //调用的还是Callable任务里面的call方法执行的，并且还会返回一个未来任务对象给我们，用f1来接，到时候会通过未来任务对象，调get方法获取这个线程执行完毕后的任务的结果
        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));

        //接下来就可以通过未来任务对象获取线程执行完毕的结果
        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

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

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

//1-2 通过Excutors创建一个线程池对象
        ExecutorService pool = Executors.newFixedThreadPool(9);//固定的三个线程
        Executors.newSingleThreadExecutor();//只提供一个线程的线程池
        //核心线程数量到底配置多少呢？？？
        //计算密集型的任务:核心线程数量=CPU的核数+1
        //IO密集型的任务:核心线程数量=CPU核数*2

计算密集型任务：比如求1-100的和，做一些计算

IO密集型任务：任务里面涉及到读取文件数据，或者进行文件通信

cpu核数怎么看：ctrl+alt+delete调出任务管理器——>性能：8核是16个逻辑处理器，就是16个线程的（十六核的）。

！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！

Executors使用可能存在的陷阱

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

！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！

OOM就是内存溢出异常

其它细节知识:并发、并行

进程

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

并发的含义

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

并行的理解

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

多线程到底是怎么在执行的?                      并发和并行同时进行的!

其它细节知识:线程的生命周期

线程的生命周期

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

Java线程的状态

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