侧边栏壁纸
  • 累计撰写 93 篇文章
  • 累计创建 85 个标签
  • 累计收到 9 条评论

JUC线程之线程的多种创建

bearjun
2021-11-10 / 0 评论 / 1 点赞 / 368 阅读 / 6,533 字 / 正在检测是否收录...
温馨提示:
本文最后更新于 2021-11-10,若内容或图片失效,请留言反馈。部分素材来自网络,若不小心影响到您的利益,请联系我们删除。

进程与线程

**进程(Process)**是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础。在当代面向线程设计的计算机结构中,进程是线程的容器。程序是指令、数据及其组织形式的描述,进程是程序的实体。是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础。程序是指令、数据及其组织形式的描述,进程是程序的实体。
**线程(thread)**是操作系统能够进行运算调度的最小单位。它被包含在进程之中,是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务。

总的来说:
进程:指在系统中正在运行的一个应用程序;程序一旦运行就是进程;进程——资源分配的最小单位。
线程:系统分配处理器时间资源的基本单元,或者说进程之内独立执行的一个单元执行流。线程——程序执行的最小单位。

打个比方:我们电脑的每一个程序都是一个进程,而程序中的某一些些的功能就可以看做是一个个线程。例如你正在谷歌浏览器上看我的这篇文章,谷歌浏览器就可以看做是一个进程。而你开的一个个小窗口就可以看做事一个个线程。

额外在补充一点:
管程(monitor):是保证了同一时刻只有一个进程在管程内活动,即管程内定义的操作在同一时刻只被一个进程调用(由编译器实现),但是这样并不能保证进程以设计的顺序执行 JVM 中同步是基于进入和退出管程(monitor)对象实现的,每个对象都会有一个管程(monitor)对象,管程(monitor)会随着 java 对象一同创建和销毁执行线程首先要持有管程对象,然后才能执行方法,当方法完成之后会释放管程,方法在执行时候会持有管程,其他线程无法再获取同一个管程。
简单来说:你可以把管程看做是锁。

多线程的创建方式

面试经常被问到,多线程的创建方式有4种:

  • 继承Thread,重写run方法
  • 实现Runnable接口,重写run方法
  • 实现Callable接口,重写call方法,再搭配FutureTask
  • 自定义线程池

继承Thread

public class test{
    public static void main(String[] args) throws InterruptedException {
        MyThread thread1 = new MyThread();
        new Thread(thread1, "线程1").start();
    }
}

public class MyThread extends Thread{

    @Override
    public void run(){
        System.out.println("多线程1");
    }
}

这个没啥说的,我们从学习java开始就接触这种创建方式。

实现Runnable接口

public class MyThread2 implements Runnable {

    @Override
    public void run() {
        System.out.println("多线程2");
    }
}

public class test {
    public static void main(String[] args) throws InterruptedException {
        // 原始方法创建
        MyThread2 thread2 = new MyThread2();
        new Thread(thread2, "线程2").start();

        // lambda表达式
        new Thread(() -> {
            System.out.println("多线程2");
        }, "线程2").start();
    }
}

这个其实也没啥好说的,注意的是现在多数是用的lambda方式来创建的多线程。

实现Callable接口

首先来看一下这个callable,它是一个函数式接口,没有参数,但是有返回值。

@FunctionalInterface
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

再来看看 FutureTask ,它是一个接口,继承了 Runnable 接口。再来看看它尽然有两个构造方法,一个可以传入 Runnable ,另外一个可以传入 Callable 。
78273-ooewd6ls58e.png

class test {
    public static void main(String[] args) throws InterruptedException, ExecutionException {

        MyThread3 thread3 = new MyThread3();
        FutureTask futureTask = new FutureTask(thread3);

        new Thread(futureTask, "多线程3").start();

        // 可以获取futureTask的返回值
        System.out.println("futureTask返回的结果:" + futureTask.get());

        // lambda表达式
        FutureTask<Integer> integerFutureTask = new FutureTask<>(() -> {
            // 有返回值
            return 2;
        });
        new Thread(integerFutureTask, "多线程3").start();
        integerFutureTask.get();
    }
}

class MyThread3 implements Callable {

    @Override
    public Object call() throws Exception {
        System.out.println("我是多线程3");
        return "多线程3";
    }
}

实现 Callable 的与前两种最大的区别就是:Callable可以返回一个值,并且 FutureTask 可以设置一个泛型,泛型的类型就是返回值的类型。需要主要的是,获取 futureTask.get() 是阻塞的。
当然,目前java已近有对 FutureTask 的升级:CompletableFuture异步编排,基本解决 FutureTask 的痛处。可以参考:JUC异步编排之CompletableFuture浅谈

自定义线程池

线程池简介

线程池(英语:thread pool):一种线程使用模式。线程过多会带来调度开销,进而影响缓存局部性和整体性能。而线程池维护着多个线程,等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用,还能防止过分调度。
举个例子: 10 年前单核 CPU 电脑,假的多线程,像马戏团小丑玩多个球,CPU 需要来回切换。 现在是多核电脑,多个线程各自跑在独立的 CPU 上,不用切换效率高。

其实们从字面就可以很好的理解,就会把很多个线程把在一个池子中,然后需要的时候从池子中去取,然后用完了再还回到池子中,方便节省开销。类似的还有数据库连接池。

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

主要特点:

  • 降低资源消耗: 通过重复利用已创建的线程降低线程创建和销毁造成的销耗。
  • 提高响应速度: 当任务到达时,任务可以不需要等待线程创建就能立即执行。
  • 提高线程的可管理性: 线程是稀缺资源,如果无限制的创建,不仅会销耗系统资源,还会降低系统的稳定性,使用线程池可以进行统一的分配,调优和监控。
  • Java 中的线程池是通过 Executor 框架实现的,该框架中用到了 Executor,Executors,
    ExecutorService,ThreadPoolExecutor 这几个类。

20797-43csih0bdvv.png

线程池的种类与创建

** newCachedThreadPool(常用) **

作用:创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。
该线程池有如下特点:

  • 线程池中数量没有固定,可达到最大值(Interger. MAX_VALUE)。
  • 线程池中的线程可进行缓存重复利用和回收(回收默认时间为 1 分钟)。
  • 当线程池中,没有可用线程,会重新创建一个线程。

适用于创建一个可无限扩大的线程池,服务器负载压力较轻,执行时间较短,任务多的场景。

** newFixedThreadPool(常用)**

作用:创建一个可重用固定线程数的线程池,以共享的无界队列方式来运行这些线程。在任意点,在大多数线程会处于处理任务的活动状态。如果在所有线程处于活动状态时提交附加任务,则在有可用线程之前,附加任务将在队列中等待。如果在关闭前的执行期间由于失败而导致任何线程终止,那么一个新线程将代替它执行后续的任务(如果需要)。在某个线程被显式地关闭之前,池中的线程将一直存在。
该线程池有如下特点:

  • 线程池中的线程处于一定的量,可以很好的控制线程的并发量。
  • 线程可以重复被使用,在显示关闭之前,都将一直存在。
  • 超出一定量的线程被提交时候需在队列中等待。

适用于可以预测线程数量的业务中,或者服务器负载较重,对线程数有严格限制的场景。

** newSingleThreadExecutor(常用)**

作用:创建一个使用单个 worker 线程的 Executor,以无界队列方式来运行该线程。(注意,如果因为在关闭前的执行期间出现失败而终止了此单个线程,那么如果需要,一个新线程将代替它执行后续的任务)。可保证顺序地执行各个任务,并且在任意给定的时间不会有多个线程是活动的。与其他等效的 newFixedThreadPool 不同,可保证无需重新配置此方法所返回的执行程序即可使用其他的线程。
该线程池有如下特点:

  • 线程池中最多执行 1 个线程,之后提交的线程活动将会排在队列中以此执行。

适用于需要保证顺序执行各个任务,并且在任意时间点,不会同时有多个线程的场景。

最后上代码:

public static void main(String[] args) throws InterruptedException, ExecutionException {

        /**
         * 通过 Executors 来创建线程池
         * Executors可以理解成线程相关的工具类,类似的还有 Collections
         */
        /**
         * 源码如下:
         * return new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
         */
        ExecutorService executorService1 = Executors.newSingleThreadExecutor();

        /**
         * 源码如下:
         * return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
         */
        ExecutorService executorService2 = Executors.newFixedThreadPool(2);

        /**
         * 源码如下:
         * return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>(), threadFactory);
         */
        ExecutorService executorService3 = Executors.newCachedThreadPool();

        // 使用
        executorService1.execute(() -> {
            System.out.println("我是多线程-线程池");
        });

    }

看到这里,嘴角是不是已近上扬了。。那你错了。。来,,我们来看一张图:
51805-vb7k35e0xkc.png

java开发手册-嵩山版的第一章第7节明确说明禁止 Executors 来创建线程池,最好能自定义创建线程池。
好了,那我们看看刚才 ThreadPoolExecutor 后面跟的7个参数:

  • corePoolSize 线程池的核心线程数
  • maximumPoolSize 能容纳的最大线程数
  • keepAliveTime 空闲线程存活时间
  • unit 存活的时间单位
  • workQueue 存放提交但未执行任务的队列
  • threadFactory 创建线程的工厂类
  • handler 等待队列满后的拒绝策略

线程池中,有三个重要的参数,决定影响了拒绝策略:corePoolSize - 核心线程数,也即最小的线程数。workQueue - 阻塞队列 。 maximumPoolSize -最大线程数。

当提交任务数大于 corePoolSize 的时候,会优先将任务放到 workQueue 阻塞队列中。当阻塞队列饱和后,会扩充线程池中线程数,直到达到maximumPoolSize 最大线程数配置。此时,再多余的任务,则会触发线程池的拒绝策略了。

总结一句话:当提交的任务数大于(workQueue.size() + maximumPoolSize ),就会触发线程池的拒绝策略。

然后再来说说拒绝策略:

  • CallerRunsPolicy: 当触发拒绝策略,只要线程池没有关闭的话,则使用调用线程直接运行任务。一般并发比较小,性能要求不高,不允许失败。但是,由于调用者自己运行任务,如果任务提交速度过快,可能导致程序阻塞,性能效率上必然的损失较大。
  • AbortPolicy: 丢弃任务,并抛出拒绝执行 RejectedExecutionException 异常信息。线程池默认的拒绝策略。必须处理好抛出的异常,否则会打断当前的执行流程,影响后续的任务执行。
  • DiscardPolicy: 默默丢弃无法处理的任务,不予处理也不抛出异常。如果允许任务丢失,该策略最好。
  • DiscardOldestPolicy: 只要线程池没有关闭的话,丢弃阻塞队列 workQueue 中最老的一个任务,并将新任务加入。

线程池底层工作流程

知道了怎么多那线程池底层到底怎么工作的呢?
74893-qrh3e0qirx.png

  • 1、在创建了线程池后,线程池中的线程数为零
  • 2、当调用 execute()方法添加一个请求任务时,线程池会做出如下判断:
    • 2.1 如果正在运行的线程数量小于 corePoolSize,那么马上创建线程运行这个任务;
    • 2.2 如果正在运行的线程数量大于或等于 corePoolSize,那么将这个任务放入队列;
    • 2.3 如果这个时候队列满了且正在运行的线程数量还小于maximumPoolSize,那么还是要创建非核心线程立刻运行这个任务;
    • 2.4 如果队列满了且正在运行的线程数量大于或等于 maximumPoolSize,那么线程池会启动饱和拒绝策略来执行。
  • 3、当一个线程完成任务时,它会从队列中取下一个任务来执行。
  • 4、当一个线程无事可做超过一定的时间(keepAliveTime)时,线程会判断:
    • 4.1 如果当前运行的线程数大于 corePoolSize,那么这个线程就被停掉。
    • 4.2 所以线程池的所有任务完成后,它最终会收缩到 corePoolSize 的大小。

总结

实际项目中创建多线程时,使用常见的三种线程池创建方式时,单一、可变、定长都有一定问题,原因是 FixedThreadPool 和 SingleThreadExecutor 底层都是用LinkedBlockingQueue 实现的,这个队列最大长度为 Integer.MAX_VALUE,容易导致 OOM。所以实际生产一般自己通ThreadPoolExecutor 的 7 个参数,自定义线程池。

1

评论区