返回顶部
首页 > 资讯 > 后端开发 > Python >Java中ExecutorService和ThreadPoolExecutor运行原理
  • 635
分享到

Java中ExecutorService和ThreadPoolExecutor运行原理

2024-04-02 19:04:59 635人浏览 泡泡鱼

Python 官方文档:入门教程 => 点击学习

摘要

目录为什么要使用线程池线程池的创建线程的提交方法具体实现总结1ThreadPoolExecutor运行原理总结2为什么要使用线程池 服务器应用程序中经常出现的情况是:单个任务处理的时

为什么要使用线程池

服务器应用程序中经常出现的情况是:单个任务处理的时间很短而请求的数目却是巨大的。

构建服务器应用程序的一个过于简单的模型应该是:每当一个请求到达就创建一个新线程,然后在新线程中为请求服务。实际上,对于原型开发这种方法工作得很好,但如果试图部署以这种方式运行的服务器应用程序,那么这种方法的严重不足就很明显。

每个请求对应一个线程(thread-per-request)方法的不足之一是:为每个请求创建一个新线程的开销很大;为每个请求创建新线程的服务器在创建和销毁线程上花费的时间和消耗的系统资源要比花在处理实际的用户请求的时间和资源更多。除了创建和销毁线程的开销之外,活动的线程也消耗系统资源(线程的生命周期!)。在一个JVM 里创建太多的线程可能会导致系统由于过度消耗内存而用完内存或“切换过度”。为了防止资源不足,服务器应用程序需要一些办法来限制任何给定时刻处理的请求数目。

线程池为线程生命周期开销问题和资源不足问题提供了解决方案。通过对多个任务重用线程,线程创建的开销被分摊到了多个任务上。其好处是,因为在请求到达时线程已经存在,所以无意中也消除了线程创建所带来的延迟。这样,就可以立即为请求服务,使应用程序响应更快。而且,通过适当地调整线程池中的线程数目,也就是当请求的数目超过某个阈值时,就强制其它任何新到的请求一直等待,直到获得一个线程来处理为止,从而可以防止资源不足。

线程池的创建


ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFORMat("thread-name").build();
    //创建线程池
ExecutorService exc = new ThreadPoolExecutor(20, 20, 30000,
            TimeUnit.MILLISECONDS, new LinkedBlockingQueue(), namedThreadFactory);


线程的提交方法

idea中,我们可以通过alt+7(注意不是F7)在左下角查看当前类的所有方法

在这里插入图片描述

在图中我们可以看到ExecutorService有execute和submit两种方法,但是他并没有实现execute方法,所以方法是灰的

接下来我们看ExecutorService的实现类ThreadPoolExecutor

在这里插入图片描述

可以看到ThreadPoolExecutor 实现了execute这个方法,那接下来我们具体看execute和submit的方法

具体实现

在我第一次学习时,我就是这么简单来理解的


exc.submit() //提交有返回值   传入的为callable和runable  返回值为future
exc.execute() //提交无返回值  传入的为runable

但是我发现为什么submit可以执行callable,又执行runable?这不是两个不同的创建线程的方式吗?我点进去了ThreadPoolExecutor类,但是在其中没有找到submit方法,于是我按了alt+7

在这里插入图片描述

在AbstractExecutorService类中发现了submit方法


public Future<?> submit(Runnable task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<Void> ftask = newTaskFor(task, null);
        execute(ftask);
        return ftask;
    }

public <T> Future<T> submit(Runnable task, T result) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task, result);
        execute(ftask);
        return ftask;
    }

public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task);
        execute(ftask);
        return ftask;
    }

在代码中我们可以看到,三个方法都是用这个代码来统一实现的,


        RunnableFuture<T> ftask = newTaskFor(task);
        execute(ftask);
        return ftask;

不同的是,当使用submit而传入的是runable接口时,会多一个返回值的参数,如果没有这个参数则会在newTaskFor中多加一个null参数,我们再进入newTaskFor方法


protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
        return new FutureTask<T>(runnable, value);
    }

protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
        return new FutureTask<T>(callable);
    }

同样存在两个方法,一个是为了接收runable,一个接收callable,但是这次都是使用了new FutureTask来传入,因为FutureTask可以运行二者

我们知道Thread实现了Runable接口可以实现线程,但关于为什么FutureTask可以运行Callable接口

首先,在下面代码中可以看到FutureTask实现了RunnableFuture,RunnableFuture实现了Runnable,所以可以用过Thread来运行start


public class FutureTask<V> implements RunnableFuture<V> 

public interface RunnableFuture<V> extends Runnable, Future<V> 


FutureTask<Integer> futureTask = new FutureTask(callableTask);
Thread thread = new Thread(futureTask);
thread.start();

而Thread中的start又是调用的接口中的run方法,但是Callable明明没有run方法啊,这就要看FutureTask中的run方法了

在这里插入图片描述

在这个FutureTask的run方法中,调用的是Callable的call方法,所以得以运行,并且将返回值另外保存了,关于异步返回值的原理下次再说。

回到new FutureTask(callable);的代码中
我们接着点进去看源码


public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }

    public FutureTask(Runnable runnable, V result) {
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       // ensure visibility of callable
    }

对于第一个传入callable的我们已经知道了原理,就是FutureTask如何通过Thread运行Callable的。
那么对于第二个传入Runable的代码又是个什么东西?


this.callable = Executors.callable(runnable, result);

好,我们再点进去看源码,进入了一个Executors,这个类没有任何的实现与继承,真是太好了,看方法


public static <T> Callable<T> callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<T>(task, result);
    }

哦豁,又将Runable传入了一个RunnableAdapter类,真复杂,就要看看到底多少层,看这个名字,Adapter,适配器?大概知道里面会有什么操作了,我们再点进去看源码


static final class RunnableAdapter<T> implements Callable<T> {
        final Runnable task;
        final T result;
        RunnableAdapter(Runnable task, T result) {
            this.task = task;
            this.result = result;
        }
        public T call() {
            task.run();
            return result;
        }
    }

这是Executors中的一个内部类,它实现了Callable接口,我依稀记得传入的是一个Runable接口,原来在这个类中,将Callable的call方法重写了,其中调用了Runable的run方法,并且具有返回值,还记得这个result吗,在最初的AbstractExecutorService中,对于传入Runable的submit方法有两个,有参数则传递,无参数则传入为null,

在这里插入图片描述

总结1

至此,就了解到了为什么submit又可以传入Runable也可以传入Callable。
接下来稍微说一下如何运行。

ThreadPoolExecutor运行原理

在这里插入图片描述

细心的小伙伴发现了,说好的submit,竟然又用execute
进入execute方法,直接用ctrl点击无效,我们打开ThreadPoolExecutor中,按alt+7,左下角execute是亮的,方法是在这里实现的


    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();

        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        else if (!addWorker(command, false))
            reject(command);
    }

先是判断线程池数量,在判断传入线程状态,满足条件就使用addWorker,不满足就reject拒绝
进入addWorker


private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {
                int wc = workerCountOf(c);
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                c = ctl.get();  // Re-read ctl
                if (runStateOf(c) != rs)
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }
        }

        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    // Recheck while holding lock.
                    // Back out on ThreadFactory failure or if
                    // shut down before lock acquired.
                    int rs = runStateOf(ctl.get());

                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                        workers.add(w);
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

这里又是一堆条件验证,都是核心代码,最后通过一个内置类worker来获取线程实例,然后加继续验证,条件都满足时,t.start(),终于可以运行


Worker w = null;
        try {
            w = new Worker(firstTask);
            final Thread t = w.thread;
            ---
            final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
            ---
            workerAdded = true;
            ---
            if (workerAdded) {
                    t.start();
            ---

总结2

至此,整个流程都已说明,关于Callable和Future完成异步返回值的原理,下次再说

到此这篇关于Java中ExecutorService和ThreadPoolExecutor运行原理的文章就介绍到这了,更多相关Java ExecutorService ThreadPoolExecutor内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网!

--结束END--

本文标题: Java中ExecutorService和ThreadPoolExecutor运行原理

本文链接: https://www.lsjlt.com/news/134087.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
  • Java中ExecutorService和ThreadPoolExecutor运行原理
    目录为什么要使用线程池线程池的创建线程的提交方法具体实现总结1ThreadPoolExecutor运行原理总结2为什么要使用线程池 服务器应用程序中经常出现的情况是:单个任务处理的时...
    99+
    2024-04-02
  • java 中ThreadPoolExecutor的原理是什么
    这篇文章将为大家详细讲解有关java 中ThreadPoolExecutor的原理是什么,文章内容质量较高,因此小编分享给大家做个参考,希望大家阅读完这篇文章后对相关知识有一定的了解。java 中ThreadPoolExecutor原理分析...
    99+
    2023-05-31
    java threadpoolexecutor ava
  • java中 Filter的运行原理
    今天就跟大家聊聊有关java中 Filter的运行原理,可能很多人都不太了解,为了让大家更加了解,小编给大家总结了以下内容,希望大家根据这篇文章可以有所收获。Java有哪些集合类Java中的集合主要分为四类:1、List列表:有序的,可重复...
    99+
    2023-06-14
  • JAVA和JVM运行原理是什么
    一、Java运行原理 (1)源码编写:Java源代码是由开发人员使用Java语言编写的,它是按照Java的语法规则进行编写的文本文件,一般以“、java”为文件扩展名。 (2)源码编译:Java源代码通过Java编译器进行编译,...
    99+
    2023-10-29
    原理 JAVA JVM
  • 源码分析Java中ThreadPoolExecutor的底层原理
    目录一、根据代码查看jdk提供的3种线程池创建二、3种方式源码分析1、Executors.newCachedThreadPool()2、Executors.newFixedThrea...
    99+
    2023-05-19
    Java ThreadPoolExecutor原理 Java ThreadPoolExecutor
  • Java的Tomcat和Servlet的运行原理详解
    目录一、客户端(浏览器)与服务器之间的交互二、Tomcat启动过程三、Tomcat处理请求过程四、Servlet的service方法总结在从前的时候,想要运行一个Java代码,就必须...
    99+
    2024-04-02
  • JAVA和JVM运行原理分别是什么
    本篇文章为大家展示了JAVA和JVM运行原理分别是什么,内容简明扼要并且容易理解,绝对能使你眼前一亮,通过这篇文章的详细介绍希望你能有所收获。JAVA和JVM运行的原理Java语言写的源程序通过Java编译器,编译成与平台无关的&l...
    99+
    2023-06-17
  • Hibernate在Java中的运行原理是什么
    这篇文章将为大家详细讲解有关Hibernate在Java中的运行原理是什么,文章内容质量较高,因此小编分享给大家做个参考,希望大家阅读完这篇文章后对相关知识有一定的了解。什么是Hibernate?      H...
    99+
    2023-05-31
    hibernate java ava
  • 如何理解SpringBoot核心运行原理和运作原理源码
    如何理解SpringBoot核心运行原理和运作原理源码,针对这个问题,这篇文章详细介绍了相对应的分析和解答,希望可以帮助更多想解决这个问题的小伙伴找到更简单易行的方法。SpringBoot核心运行原理Spr...
    99+
    2024-04-02
  • Java线程运行的原理详解
    目录栈与栈帧线程的上下文切换总结栈与栈帧 JVM中由堆、栈、方法区所组成,其中栈内存就是分配给线程使用的,每个线程启动后,虚拟机都会为其分配一块栈内存。 每个栈由多个栈帧组成,对应着...
    99+
    2024-04-02
  • 【Linux】Shell运行原理和Linux权限
    大家好我是沐曦希💕 文章目录 1.shell命令以及运行原理2.Linux权限的概念3.Linux权限管理4.文件访问者的分类(人)5.文件类型和访问权限(事物属性)5.1 基本权限 6.文件权限值的表示方...
    99+
    2023-08-19
    linux 服务器 运维
  • MapReduce的运行原理
    本篇内容介绍了“MapReduce的运行原理”的有关知识,在实际案例的操作过程中,不少人都会遇到这样的困境,接下来就让小编带领大家学习一下如何处理这些情况吧!希望大家仔细阅读,能够学有所成!MapReduce是一种编程模型,用于大规模数据集...
    99+
    2023-06-02
  • Laravel框架运行原理
    下文介绍Laravel框架运行原理,希望对大家有帮助。 使用任何框架,如果理解该框架原理,应用起来会更加得心应手。 一、生命周期 1. 入口文件: Laravel框架所有请求入口统一进入/public/i...
    99+
    2024-04-02
  • 分析mybatis运行原理
    目录一、Mybatis基本认识1.1、动态代理1.2、反射二、Configuration对象作用三、映射器结构四、sqlsession执行流程(源码跟踪)4.1、Executor4....
    99+
    2024-04-02
  • 前端 JavaScript运行原理
    目录1、什么是JavaScript引擎2、V8引擎3、运行时环境4、运行时的调用栈5、异步任务6、总结1、什么是JavaScript引擎 JavaScript引擎是一个计算机程序,它...
    99+
    2024-04-02
  • php的运行机制和原理是什么
    PHP的运行机制和原理如下: 客户端请求:当用户在浏览器中输入一个URL并发送请求时,服务器会接收到该请求。 Web服务器:...
    99+
    2023-10-28
    php
  • java虚拟主机运行的原理是什么
    Java虚拟主机(JVM)是一个虚拟的计算机,它运行在真实计算机上。JVM可以执行Java字节码文件,将其转换为可执行代码并在操作系...
    99+
    2023-06-12
    java虚拟主机 虚拟主机
  • java嵌套循环的运行原理是什么
    Java中的嵌套循环是通过嵌套多个循环语句来实现的。嵌套循环的运行原理是外部循环执行一次,内部循环会完整地执行完一遍,然后外部循环再...
    99+
    2023-09-13
    java
  • Nodejs 中libuv运行的原理是什么
    Nodejs 中libuv运行的原理是什么,相信很多没有经验的人对此束手无策,为此本文总结了问题出现的原因和解决方法,通过这篇文章希望你能解决这个问题。1) libuv的架构2) 案例,从细节的角度看lib...
    99+
    2024-04-02
  • SparkSQl中运行原理的示例分析
    这篇文章将为大家详细讲解有关SparkSQl中运行原理的示例分析,小编觉得挺实用的,因此分享给大家做个参考,希望大家阅读完这篇文章后可以有所收获。一:什么是SparkSQL?(一)SparkSQL简介Spark SQL是Spark的一个模块...
    99+
    2023-06-20
软考高级职称资格查询
编程网,编程工程师的家园,是目前国内优秀的开源技术社区之一,形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容,为IT开发者提供了一个发现、使用、并交流开源技术的平台。
  • 官方手机版

  • 微信公众号

  • 商务合作