线程池(一)

SONNIE在路上

已于 2022-03-10 18:16:13 修改

阅读量138

点赞数

分类专栏： JUC 文章标签：多线程 java 并发编程 thread

于 2021-05-19 07:06:18 首次发布

本文链接：https://blog.csdn.net/qq_44469202/article/details/117012143

版权

JUC 专栏收录该内容

18 篇文章 1 订阅

订阅专栏

线程池

1.Callable接口

Callable: 返回结果并且可能抛出异常的任务。

优点：

可以获得任务执行返回值；
通过与Future的结合，可以实现利用Future来跟踪异步计算的结果。

Runnable和Callable的区别：

1、Callable规定的方法是call(),Runnable规定的方法是run().
2、Callable的任务执行后可返回值，而Runnable的任务是不能返回值得
3、call方法可以抛出异常，run方法不可以
4、运行Callable任务可以拿到一个Future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。

Future接口

Future是一个接口，代表了一个异步计算的结果。接口中的方法用来检查计算是否完成、等待完成和得到计算的结果。
当计算完成后，只能通过get()方法得到结果，get方法会阻塞直到结果准备好了。
如果想取消，那么调用cancel()方法。其他方法用于确定任务是正常完成还是取消了。
一旦计算完成了，那么这个计算就不能被取消。

FutureTask类

FutureTask类实现了RunnableFuture接口，而RunnnableFuture接口继承了Runnable和Future接口，所以说FutureTask是一个提供异步计算的结果的任务。
FutureTask可以用来包装Callable或者Runnbale对象。因为FutureTask实现了Runnable接口，所以FutureTask也可以被提交给Executor。

FutrueTask作为中间人（适配器）接受实现Callable的类对象，返回实现Runnable接口的类对象；
因为FutrueTask实现了Runnable接口，就跟Runnable接口一样传入Thread中构造即可。

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

Callable两种执行方式

借助FutureTask执行

FutureTask类同时实现了两个接口，Future和Runnable接口，所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。

package com.example.juctest;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;

/**
 * @author Sonnie Guo
 * @PackageName:com.example.juctest
 * @ClassName:CallableDemo01
 * @Description:CallableDemo01x
 */
public class CallableDemo01 {
    public static void main(String[] args) {
//        查看处理器个数
        System.out.println(Runtime.getRuntime().availableProcessors());

//        FutureTask实现了RunnableFuture接口，构造函数中含有Callable
        FutureTask<Integer> futureTask = new FutureTask(new MyThread());
//        多个线程共享 Futuretask
        new Thread(futureTask,"AAA").start();
        new Thread(futureTask,"BBB").start();
        while (!futureTask.isDone()){
            // Do something here=
        }
        Integer num = 1024;
        try {
            System.out.println(futureTask.get()+num);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

//class Thread01 implements Runnable{
//    @Override
//    public void run(){
//
//    }
//}

class MyThread implements Callable<Integer> {
    @Override
    public Integer call() throws Exception{
        System.out.println("come in Callable!");
        try {
//            模拟耗时操作
            TimeUnit.SECONDS.sleep(2);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            return 1024;
        }
    }
}

借助线程池来运行

2.为什么要用线程池，线程池的优势？

线程池做的工作主要是控制运行的线程的数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量，超出数量的线程排队等候，等其它线程执行完毕，再从队列中取出任务来执行。

线程池的主要特点为：线程复用；控制最大并发数；管理线程。

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

3.如何使用线程池？

Java中线程池的创建涉及到：

Executor
Executors
ExecutorService
ThreadPoolExecutor

4.线程池分类

了解：

Executor：newScheduledThreadPool()，带时间调度的线程池
Executors.newWorkStealingPool(int)：java8新增，使用目前机器上可用的处理器作为它的并行

重要：

Executors.newFixedThreadPool(int)：
- 固定线程数量的线程池
- 可控制线程最大并发数，超出的部分在阻塞队列中等待
- 创建的线程池corePoolSize和maximumPoolSize值是相等的，它使用的LinkedBlockingQueue 阻塞队列
- 适合于执行长期的任务，性能好很多
Executors.newSingleThreadExecutor()：
- 单线程化的线程池
- 只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序执行
- 创建的线程池corePoolSize和maximumPoolSize都为1，它使用的LinkedBlockingQueue 阻塞队列
- 适合于一个任务一个任务执行的场景
Executors.newCachedThreadPool()：执行很多短期异步的小程序或者负载较轻的服务器
- 自适应线程数量的线程池/可缓存线程池
- 将线程池corePoolSiz设置为了0，maximumPoolSize为Integer.MAX_VALUE，keepAliveTime为60s
- 使用的SynchronousQueue阻塞队列，也就是说来了任务就创建线程运行，当线程空闲超过60秒，就销毁线程

5.线程池使用步骤

创建线程池
使用线程池
关闭线程池

package com.example.juctest;

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

/**
 * @author Sonnie Guo
 * @PackageName:com.example.juctest
 * @ClassName:ThreadPoolDemo
 * @Description:ThreadPoolDemo
 */
public class ThreadPoolDemo {

    public static void main(String[] args) {
        try {
            fixedThreadPoolDemo();
            TimeUnit.SECONDS.sleep(1);
            cacheThreadPoolDemo();
            TimeUnit.SECONDS.sleep(1);
            singleThreadPoolDemo();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void fixedThreadPoolDemo() {
        System.out.println("-----------------fixedThreadPoolDemo----------------");
        ExecutorService threadPool = Executors.newFixedThreadPool(5);

        try {
            for (int i = 0; i < 10; i++) {
                threadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "\t正在处理业务");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }
    }

    public static void singleThreadPoolDemo() {
        System.out.println("-----------------singleThreadPoolDemo----------------");
        ExecutorService threadPool = Executors.newSingleThreadExecutor();

        try {
            for (int i = 0; i < 10; i++) {
                threadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "\t正在处理业务");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }
    }

    public static void cacheThreadPoolDemo() {
        System.out.println("-----------------cacheThreadPoolDemo----------------");
        ExecutorService threadPool = Executors.newCachedThreadPool();

        try {
            for (int i = 0; i < 10; i++) {
                threadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "\t正在处理业务");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }
    }

}

6.线程池7大参数

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

corePoolSize:线程池中的常驻核心线程数;

创建线程池之后，如果有请求进来，线程池中的线程就会去执行请求任务；

如果线程池中的线程数达到corePoolSize后，就会把到达的任务放到阻塞队列中；
maximumPoolSize:最大线程数，只有当阻塞队列满了不能在添加任务时，这个参数才会生效，
keepAliveTime:超出corePoolSize大小的空闲线程的最大存活时间并且时间一到，这些空闲线程会被销毁，直到只剩下corePoolSize个线程为止
unit:空闲线程最大存活时间的单位
workQueue:阻塞队列
threadFactory:线程工厂，用来创建线程，一般默认就好
handler:拒绝策略，当线程池中的线程数已经达到了最大线程数并且阻塞i队列中也满时，将执行拒绝策略。

7.线程池底层原理/工作机制？

1.创建线程池之后，等待提交过来的请求；
2.当调用execute()方法添加任务请求时，会先将正在运行的线程数与corePoolSize作比较，
- 如果小于corePoolSize,就会马上创建线程执行请求；
- 如果等于或者大于corePoolSize，就会将这个请求加入到阻塞队列中；
- 如果阻塞队列满了，就会先将正在运行的线程数与maxmumPoolSize作比较
  - 如果小于maxmumPoolSize,则创建非核心线程执行任务；
  - 如果大于或者等于，这是线程池就会执行拒绝策略；
当一个线程完成任务时，就会从阻塞队列中取出下一个任务请求，来执行；
当一个线程执行完任务无所事事，线程池就会判断
- 如果正在运行的线程数量大于corePoolSize,那么一旦到达keepAliveTime,就会将这个线程停掉，当所有线程都执行完任务时，线程池会销毁多余的线程，重新收缩到corePoolSize的大小。

理解：线程池就像一个银行。

corePoolSize就像银行的“当值窗口“，比如今天有2位柜员在受理客户请求（任务）。如果超过2个客户，那么新的客户就会在等候区（等待队列workQueue）等待。
当等候区也满后，又来了几位客户，这个时候就要开启“加班窗口”，让其它3位柜员来加班，此时达到最大窗口maximumPoolSize，为5个。emmm …，但后来的客户会抢占等候区客户的机会，先办理业务
如果开启了所有窗口，等候区依然满员，此时就应该启动”拒绝策略“handler，告诉不断涌入的客户，叫他们不要进入，已经爆满了。
由于不再涌入新客户，加班窗口逐渐开始空闲，这个时候就通过keepAlivetTime将多余的3个”加班窗口“取消，恢复到2个”当值窗口“。

8.线程池的拒绝策略

拒绝策略是什么？

等待队列也已经排满了，再也塞不下新任务了，同时线程池中的max线程也达到了，无法继续为新任务服务。
这时候我们就需要拒绝策略机制合理的处理这个问题。

JDK内置拒绝策略（以下内置策略均实现了RejectedExecutionHandler接口）

AbortPolicy（默认）：直接抛出RejectedExecutionException异常阻止系统正常运行
CallerRunsPolicy：调用者运行，该策略既不会抛弃任务，也不会抛出异常，而是将某些任务回退给调用者，从而降低新任务的流量
DiscardOldestPolicy：抛弃队列中等待最久的任务，然后把当前任务加入队列中尝试再次提交当前任务
DiscardPolicy：直接丢弃任务，不予任何处理也不抛出异常。如果允许任务丢失，这是最好的一种方案

9.三种创建线程池的方法，用哪个多？

一个都不用！

阿里开发手册规定：

线程资源必须通过线程池来提供，不允许显式的创建线程；
线程池不允许使用Executors创建，而应该使用ThreadPoolExecutor的方式。
这样的处理方式可以更明确线程池的运行规则，规避资源耗尽的风险。

为什么不能用Executors创建线程池呢？

fixedThreadPool和singleThreadPool的阻塞队列使用的都是LinkedBlockiingQueue，该阻塞队列默认是无界的，允许的最大请求队列长度是Integer.MAX_VALUE，这会堆积大量的请求，从而导致OOM；
cachedThreadPool和scheduledThreadPool允许创建的线程数量是Integer_MAX_VALUE，可能会创建大量线程，从而导致OOM。

10.手写线程池

package com.example.juctest.threadPool;

import java.util.concurrent.*;

/**
 * @author Sonnie Guo
 * @PackageName:com.example.juctest.threadPool
 * @ClassName:MyThreadPool
 * @Description:MyThreadPool
 */
public class MyThreadPool {

    public static void main(String[] args) {
        ThreadPoolExecutor myThreadPoolExecutor = new ThreadPoolExecutor(2,
                5,
                10,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<Runnable>(5),
                Executors.defaultThreadFactory(),
//                new ThreadPoolExecutor.AbortPolicy());
                new ThreadPoolExecutor.DiscardPolicy());
//                new ThreadPoolExecutor.DiscardOldestPolicy());
//                new ThreadPoolExecutor.CallerRunsPolicy());
        try {
            for (int i = 0;i < 11;i++){
                myThreadPoolExecutor.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"\t正在执行任务");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            myThreadPoolExecutor.shutdown();
        }
    }

}

11.如何何理配置线程池？

需要根据自己的CPU核数和业务类型来配置，看自己的业务是CPU密集型还是IO密集型。

CPU 密集型

CPU密集的意思是该任务需要大量的运算，而没有阻塞，CPU一直全速运行。
CPU密集任务只有在真正的多核CPU上才可能得到加速（通过多线程），而在单核CPU上无论你开几个模拟的多线程该任务都不可能得到加速，因为CPU总的运算能力就那些。
CPU密集型任务配置尽可能少的线程数量，一般公式：CPU核数+1个线程的线程池
IO 密集型
- 由于IO密集型任务线程并不是一直在执行任务，所以应该配置尽可能多的线程，如CPU核数*2。
- IO密集型，即该任务需要大量的IO，即大量的阻塞。
  在单线程上运行IO密集型的任务会导致浪费大量的CPU运算能力浪费在等待。
  所以在IO密集型任务中使用多线程可以大大的加速程序运行，在单核CPU上，这种加速主要就是利用了被浪费掉的阻塞时间。
  IO密集型时，大部分线程都阻塞，故需要多配置线程数：参考公式：CPU核数/(1-阻塞系数)，阻塞系数在0.8~0.9之间，比如8核CPU：8/(1-0.9)=80个线程数

12.线程池中阻塞队列的作用？

一般的队列只能保证作为一个有限长度的缓冲区，如果超出了缓冲长度，就无法保留当前的任务了；而阻塞队列可以通过阻塞来保留当前想要持续入队的任务；
当任务队列中没有任务时，阻塞队列可以阻塞获取任务的线程，使得线程进入wait状态，并释放CPU资源；阻塞队列自带阻塞与唤醒的功能，不需要额外处理；

13.为什么要先添加队列而不是创建最大线程？

因为在创建新线程时需要获取全局锁，所以这个时候其他的线程都得阻塞，影响整体效率。

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