Java开发大厂面试第04讲：深入理解ThreadPoolExecutor，参数含义与源码执行流程全解

线程池是为了避免线程频繁的创建和销毁带来的性能消耗，而建立的一种池化技术，它是把已创建的线程放入“池”中，当有任务来临时就可以重用已有的线程，无需等待创建的过程，这样就可以有效提高程序的响应速度。但如果要说线程池的话一定离不开 ThreadPoolExecutor ，在阿里巴巴的《Java 开发手册》中是这样规定线程池的：

线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的读者更加明确线程池的运行规则，规避资源耗尽的风险。

说明：Executors 返回的线程池对象的弊端如下：

  • FixedThreadPool 和 SingleThreadPool：允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。

  • CachedThreadPool 和 ScheduledThreadPool：允许的创建线程数量为 Integer.MAX_VALUE，可能会创建大量的线程，从而导致 OOM。

  • `ThreadPoolExecutor` 是 Java 中用于创建和管理线程池的类。它允许你控制线程池的大小、工作队列的大小和线程的创建方式等。下面是 `ThreadPoolExecutor` 构造函数的参数含义：

  1. corePoolSize（核心线程数）:

    • 线程池中保持活动状态的最小线程数。
    • 即使在没有任务需要执行时，线程池也会保持 corePoolSize 数量的线程。
    • 如果当前线程数少于 corePoolSize，则创建新线程来处理新提交的任务。

  2. maximumPoolSize（最大线程数）:

    • 线程池中允许的最大线程数。
    • 当工作队列已满，并且当前线程数小于 maximumPoolSize 时，线程池会创建新的线程来处理任务。
    • 注意，这个值不能超过 Integer.MAX_VALUE。

  3. keepAliveTime（空闲线程存活时间）:

    • 当线程数大于 corePoolSize 时，这是多余的空闲线程在终止前等待新任务的最长时间。
    • 这个时间只对非核心线程有效。
    • 如果在 keepAliveTime 时间段内没有新的任务提交，那么非核心线程将被终止。

  4. unit（时间单位）:

    • 用于 keepAliveTime 参数的时间单位，如 TimeUnit.SECONDS、TimeUnit.MILLISECONDS 等。

  5. workQueue（工作队列）:

    • 用于保存待执行的任务的队列。
    • 它是一个 BlockingQueue，用于存放待执行的任务。
    • 当核心线程都在忙碌时，新任务将被放入此队列中等待执行。

  6. threadFactory（线程工厂）:

    • 用于创建新线程的工厂。
    • 你可以通过自定义的 ThreadFactory 来设置新线程的创建方式，如设置线程名称、优先级等。

  7. handler（拒绝策略）:

    • 当工作队列已满，并且线程数已达到 maximumPoolSize 时，如果再有新的任务提交，线程池将使用此拒绝策略来处理该任务。
    • Java 提供了几种预定义的拒绝策略，如 AbortPolicy（直接抛出异常）、CallerRunsPolicy（调用者运行任务）、DiscardPolicy（丢弃任务）和 DiscardOldestPolicy（丢弃队列中最旧的任务）。

关于 ThreadPoolExecutor 的源码执行流程，这涉及到具体的实现细节和并发控制，因此在这里只能给出一个大致的概述：

  • 当提交新任务到 ThreadPoolExecutor 时，它首先会尝试使用核心线程来执行该任务。
  • 如果核心线程都在忙碌，并且工作队列未满，那么任务将被放入工作队列中等待执行。
  • 如果工作队列已满，并且当前线程数小于 maximumPoolSize，那么线程池将创建新的线程来执行任务。
  • 如果工作队列已满，并且线程数已达到 maximumPoolSize，那么线程池将使用拒绝策略来处理该任务。

在整个过程中，ThreadPoolExecutor 使用了内部锁和条件变量来实现对线程和任务的并发控制。它还提供了丰富的 API 来监控和管理线程池的状态，如获取线程池大小、当前活跃线程数、已完成任务数等。

其实当我们去看 Executors 的源码会发现，Executors.newFixedThreadPool()、Executors.newSingleThreadExecutor() 和 Executors.newCachedThreadPool() 等方法的底层都是通过 ThreadPoolExecutor 实现的，所以本课时我们就重点来了解一下 ThreadPoolExecutor 的相关知识，比如它有哪些核心的参数？它是如何工作的？

典型回答

ThreadPoolExecutor 的核心参数指的是它在构建时需要传递的参数，其构造方法如下所示：

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {
    if (corePoolSize < 0 ||
        // maximumPoolSize 必须大于 0，且必须大于 corePoolSize
        maximumPoolSize <= 0 ||
        maximumPoolSize < corePoolSize ||
        keepAliveTime < 0)
        throw new IllegalArgumentException();
    if (workQueue == null || threadFactory == null || handler == null)
        throw new NullPointerException();
    this.acc = System.getSecurityManager() == null ?
            null :
            AccessController.getContext();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

第 1 个参数：corePoolSize 表示线程池的常驻核心线程数。如果设置为 0，则表示在没有任何任务时，销毁线程池；如果大于 0，即使没有任务时也会保证线程池的线程数量等于此值。但需要注意，此值如果设置的比较小，则会频繁的创建和销毁线程（创建和销毁的原因会在本课时的下半部分讲到）；如果设置的比较大，则会浪费系统资源，所以开发者需要根据自己的实际业务来调整此值。

第 2 个参数：maximumPoolSize 表示线程池在任务最多时，最大可以创建的线程数。官方规定此值必须大于 0，也必须大于等于 corePoolSize，此值只有在任务比较多，且不能存放在任务队列时，才会用到。

第 3 个参数：keepAliveTime 表示线程的存活时间，当线程池空闲时并且超过了此时间，多余的线程就会销毁，直到线程池中的线程数量销毁的等于 corePoolSize 为止，如果 maximumPoolSize 等于 corePoolSize，那么线程池在空闲的时候也不会销毁任何线程。

第 4 个参数：unit 表示存活时间的单位，它是配合 keepAliveTime 参数共同使用的。

第 5 个参数：workQueue 表示线程池执行的任务队列，当线程池的所有线程都在处理任务时，如果来了新任务就会缓存到此任务队列中排队等待执行。

第 6 个参数：threadFactory 表示线程的创建工厂，此参数一般用的比较少，我们通常在创建线程池时不指定此参数，它会使用默认的线程创建工厂的方法来创建线程，源代码如下：

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue) {
    // Executors.defaultThreadFactory() 为默认的线程创建工厂
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), defaultHandler);
}
public static ThreadFactory defaultThreadFactory() {
    return new DefaultThreadFactory();
}
// 默认的线程创建工厂，需要实现 ThreadFactory 接口
static class DefaultThreadFactory implements ThreadFactory {
    private static final AtomicInteger poolNumber = new AtomicInteger(1);
    private final ThreadGroup group;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;

    DefaultThreadFactory() {
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() :
                              Thread.currentThread().getThreadGroup();
        namePrefix = “pool-” +
                      poolNumber.getAndIncrement() +
                     “-thread-”;
    }
    // 创建线程
    public Thread newThread(Runnable r) {
        Thread t = new Thread(group, r,
                              namePrefix + threadNumber.getAndIncrement(),
                              0);
        if (t.isDaemon()) 
            t.setDaemon(false); // 创建一个非守护线程
        if (t.getPriority() != Thread.NORM_PRIORITY)
            t.setPriority(Thread.NORM_PRIORITY); // 线程优先级设置为默认值
        return t;
    }
}

我们也可以自定义一个线程工厂，通过实现 ThreadFactory 接口来完成，这样就可以自定义线程的名称或线程执行的优先级了。

第 7 个参数：RejectedExecutionHandler 表示指定线程池的拒绝策略，当线程池的任务已经在缓存队列 workQueue 中存储满了之后，并且不能创建新的线程来执行此任务时，就会用到此拒绝策略，它属于一种限流保护的机制。

线程池的工作流程要从它的执行方法 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);
        // 如果线程池的线程数为 0 时（当 corePoolSize 设置为 0 时会发生）
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false); // 新建线程执行任务
    }
    // 核心线程都在忙且队列都已爆满，尝试新启动一个线程执行失败
    else if (!addWorker(command, false)) 
        // 执行拒绝策略
        reject(command);
}

其中 addWorker(Runnable firstTask, boolean core) 方法的参数说明如下：

  • firstTask，线程应首先运行的任务，如果没有则可以设置为 null；

  • core，判断是否可以创建线程的阀值（最大值），如果等于 true 则表示使用 corePoolSize 作为阀值，false 则表示使用 maximumPoolSize 作为阀值。

考点分析

本课时的这道面试题考察的是你对于线程池和 ThreadPoolExecutor 的掌握程度，也属于 Java 的基础知识，几乎所有的面试都会被问到，其中线程池任务执行的主要流程，可以参考以下流程图：

与 ThreadPoolExecutor 相关的面试题还有以下几个：

  • ThreadPoolExecutor 的执行方法有几种？它们有什么区别？

  • 什么是线程的拒绝策略？

  • 拒绝策略的分类有哪些？

  • 如何自定义拒绝策略？

  • ThreadPoolExecutor 能不能实现扩展？如何实现扩展？

知识扩展

execute() VS submit()

execute() 和 submit() 都是用来执行线程池任务的，它们最主要的区别是，submit() 方法可以接收线程池执行的返回值，而 execute() 不能接收返回值。

来看两个方法的具体使用：

ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 10, 10L,
        TimeUnit.SECONDS, new LinkedBlockingQueue(20));
// execute 使用
executor.execute(new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello, execute.");
    }
});
// submit 使用
Future<String> future = executor.submit(new Callable<String>() {
    @Override
    public String call() throws Exception {
        System.out.println("Hello, submit.");
        return "Success";
    }
});
System.out.println(future.get());

以上程序执行结果如下：

Hello, submit.
Hello, execute.
Success

从以上结果可以看出 submit() 方法可以配合 Futrue 来接收线程执行的返回值。它们的另一个区别是 execute() 方法属于 Executor 接口的方法，而 submit() 方法则是属于 ExecutorService 接口的方法，它们的继承关系如下图所示：

线程池的拒绝策略

当线程池中的任务队列已经被存满，再有任务添加时会先判断当前线程池中的线程数是否大于等于线程池的最大值，如果是，则会触发线程池的拒绝策略。

Java 自带的拒绝策略有 4 种：

  • AbortPolicy，终止策略，线程池会抛出异常并终止执行，它是默认的拒绝策略；

  • CallerRunsPolicy，把任务交给当前线程来执行；

  • DiscardPolicy，忽略此任务（最新的任务）；

  • DiscardOldestPolicy，忽略最早的任务（最先加入队列的任务）。

例如，我们来演示一个 AbortPolicy 的拒绝策略，代码如下：

ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 3, 10,
        TimeUnit.SECONDS, new LinkedBlockingQueue<>(2),
        new ThreadPoolExecutor.AbortPolicy()); // 添加 AbortPolicy 拒绝策略
for (int i = 0; i < 6; i++) {
    executor.execute(() -> {
        System.out.println(Thread.currentThread().getName());
    });
}

以上程序的执行结果：

pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-3
pool-1-thread-2
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task com.lagou.interview.ThreadPoolExample$$Lambda$1/1096979270@448139f0 rejected from java.util.concurrent.ThreadPoolExecutor@7cca494b[Running, pool size = 3, active threads = 3, queued tasks = 2, completed tasks = 0]
 at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2063)
 at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:830)
 at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1379)
 at com.lagou.interview.ThreadPoolExample.rejected(ThreadPoolExample.java:35)
 at com.lagou.interview.ThreadPoolExample.main(ThreadPoolExample.java:26)

可以看出当第 6 个任务来的时候，线程池则执行了 AbortPolicy  拒绝策略，抛出了异常。因为队列最多存储 2 个任务，最大可以创建 3 个线程来执行任务（2+3=5），所以当第 6 个任务来的时候，此线程池就“忙”不过来了。

自定义拒绝策略

自定义拒绝策略只需要新建一个 RejectedExecutionHandler 对象，然后重写它的 rejectedExecution() 方法即可，如下代码所示：

ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 3, 10,
        TimeUnit.SECONDS, new LinkedBlockingQueue<>(2),
        new RejectedExecutionHandler() {  // 添加自定义拒绝策略
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                // 业务处理方法
                System.out.println("执行自定义拒绝策略");
            }
        });
for (int i = 0; i < 6; i++) {
    executor.execute(() -> {
        System.out.println(Thread.currentThread().getName());
    });
}

以上代码执行的结果如下：

执行自定义拒绝策略
pool-1-thread-2
pool-1-thread-3
pool-1-thread-1
pool-1-thread-1
pool-1-thread-2

可以看出线程池执行了自定义的拒绝策略，我们可以在 rejectedExecution 中添加自己业务处理的代码。

ThreadPoolExecutor 扩展

ThreadPoolExecutor 的扩展主要是通过重写它的 beforeExecute() 和 afterExecute() 方法实现的，我们可以在扩展方法中添加日志或者实现数据统计，比如统计线程的执行时间，如下代码所示：

public class ThreadPoolExtend {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 线程池扩展调用
        MyThreadPoolExecutor executor = new MyThreadPoolExecutor(2, 4, 10,
                TimeUnit.SECONDS, new LinkedBlockingQueue());
        for (int i = 0; i < 3; i++) {
            executor.execute(() -> {
                Thread.currentThread().getName();
            });
        }
    }
   /**
     * 线程池扩展
     */
    static class MyThreadPoolExecutor extends ThreadPoolExecutor {
        // 保存线程执行开始时间
        private final ThreadLocal<Long> localTime = new ThreadLocal<>();
        public MyThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime,
                            TimeUnit unit, BlockingQueue<Runnable> workQueue) {
    super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
}
        /**
         * 开始执行之前
         * @param t 线程
         * @param r 任务
         */
        @Override
        protected void beforeExecute(Thread t, Runnable r) {
            Long sTime = System.nanoTime(); // 开始时间 (单位：纳秒)
            localTime.set(sTime);
            System.out.println(String.format("%s | before | time=%s",
                    t.getName(), sTime));
            super.beforeExecute(t, r);
        }
        /**
         * 执行完成之后
         * @param r 任务
         * @param t 抛出的异常
         */
        @Override
        protected void afterExecute(Runnable r, Throwable t) {
            Long eTime = System.nanoTime(); // 结束时间 (单位：纳秒)
            Long totalTime = eTime - localTime.get(); // 执行总时间
            System.out.println(String.format("%s | after | time=%s | 耗时：%s 毫秒",
                    Thread.currentThread().getName(), eTime, (totalTime / 1000000.0)));
            super.afterExecute(r, t);
        }
    }
}

以上程序的执行结果如下所示：

pool-1-thread-1 | before | time=4570298843700
pool-1-thread-2 | before | time=4570298840000
pool-1-thread-1 | after | time=4570327059500 | 耗时：28.2158 毫秒
pool-1-thread-2 | after | time=4570327138100 | 耗时：28.2981 毫秒
pool-1-thread-1 | before | time=4570328467800
pool-1-thread-1 | after | time=4570328636800 | 耗时：0.169 毫秒

最后

最后我们总结一下：线程池的使用必须要通过 ThreadPoolExecutor 的方式来创建，这样才可以更加明确线程池的运行规则，规避资源耗尽的风险。同时，也介绍了 ThreadPoolExecutor 的七大核心参数，包括核心线程数和最大线程数之间的区别，当线程池的任务队列没有可用空间且线程池的线程数量已经达到了最大线程数时，则会执行拒绝策略，Java 自动的拒绝策略有 4 种，用户也可以通过重写 rejectedExecution() 来自定义拒绝策略，我们还可以通过重写 beforeExecute() 和 afterExecute() 来实现 ThreadPoolExecutor 的扩展功能。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/629243.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

tomcat--java的安装

tomcat--java的安装

组成 语言、语法规范。关键字,如: if、for、class等源代码 source code依赖库&#xff0c;标准库(基础)、第三方库(针对某些应用)。由于底层代码太难使用且开发效率低&#xff0c;封装成现成的库JVM虚拟机。将源代码编译为中间码即字节码后,再运行在JVM之上 jdk和jre 概念 j…
阅读更多...
水离子雾化壁炉与会所房间的氛围搭配

水离子雾化壁炉与会所房间的氛围搭配

水离子雾化壁炉在会所房间的氛围搭配可以为房间增添舒适、温馨和现代感&#xff0c;以下是一些建议&#xff1a; 主题定位&#xff1a; 根据会所房间的主题和定位选择合适的水离子雾化壁炉款式和设计风格。可以是现代简约、欧式古典或是豪华奢华&#xff0c;确保与房间整体风格…
阅读更多...
nginx反向代理kafka集群实现内外网隔离访问 —— 筑梦之路

nginx反向代理kafka集群实现内外网隔离访问 —— 筑梦之路

背景说明 我们在使用Kafka客户端连接到Kafka集群时&#xff0c;即使连接的节点只配置了一个集群的Broker地址&#xff0c;该Broker将返回给客户端集群所有节点的信息列表。然后客户端使用该列表信息&#xff08;Topic的分区信息&#xff09;再与集群进行数据交互。这里Kafka列表…
阅读更多...
MQTT_客户端安装_1.4

MQTT_客户端安装_1.4

下载地址 MQTTX 下载 下一步直接安装即可 界面介绍
阅读更多...
Lambda 表达式详解

Lambda 表达式详解

LAMBDA ⚪ λ 希腊字母表中排序第十一位的字母, 英语名称为Lambda ⚪ 避免匿名内部类定义过多 ⚪ 其实质属于函数式编程的概念 ⚪ 也可称为闭包 ⚪ Lambda允许把一个函数作为方法的参数&#xff08;函数作为参数传递进方法中&#xff09;。 Lambda是在jdk8之后出现的所以现…
阅读更多...
【数据可视化-05】：Plotly数据可视化宝典

【数据可视化-05】：Plotly数据可视化宝典

一、引言 数据可视化是机器学习流程中不可或缺的一部分。通过图形和图表展示数据&#xff0c;我们可以更直观地理解数据的分布、趋势和关联&#xff0c;从而更有效地进行数据分析、特征工程和模型评估。Plotly是一个功能强大且灵活的数据可视化库&#xff0c;它提供了丰富的图表…
阅读更多...
人物介绍模板 PSD 源文件免费获取

人物介绍模板 PSD 源文件免费获取

免费获取 下载链接在最后&#xff01; 下载链接在最后&#xff01; 下载链接在最后&#xff01; 下载链接在最后&#xff01; 下载链接在最后&#xff01; 链接&#xff1a;https://pan.baidu.com/s/1sq3e6djMdZt76Sh_uqVxWg 提取码&#xff1a;naun
阅读更多...
相约蓉城 | 全视通邀您参加 CHCC 2024第25届全国医院建设大会

相约蓉城 | 全视通邀您参加 CHCC 2024第25届全国医院建设大会

第25届全国医院建设大会暨国际医院建设、装备及管理展览会&#xff08;CHCC2024&#xff09;&#xff0c;将于5月17日-19日在成都中国西部国际博览城盛大启幕。 全视通将携智慧病房、智慧门诊、智慧手术室、智慧后勤、智慧康养等产品方案亮相11号厅K05展位&#xff0c;期待与您…
阅读更多...
Math.Round()函数说明

Math.Round()函数说明

Math.Round()并不是严格意义上的是四舍五入函数。它默认的执行的是“银行家舍入”算法&#xff0c;即四舍六入五取偶。概括为&#xff1a;四舍六入五考虑、五后非零就进一&#xff0c;五后皆零看奇偶&#xff0c;五前为偶应舍去、五前为奇要进一。 当为5时&#xff0c;取离着最…
阅读更多...
TypeScript学习日志-第二十四天（webpack构建ts+vue3）

TypeScript学习日志-第二十四天（webpack构建ts+vue3）

webpack构建tsvue3 一、构建项目目录 如图&#xff1a; shim.d.ts 这个文件用于让ts识别.vue后缀的 后续会说 并且给 tsconfig.json 增加配置项 "include": ["src/**/*"] 二、基础构建 安装依赖 安装如下依赖&#xff1a; npm install webpack -D …
阅读更多...
python实现贪吃蛇游戏，python贪吃蛇

python实现贪吃蛇游戏，python贪吃蛇

欢迎关注我👆，收藏下次不迷路┗|｀O′|┛ 嗷~~ 目录 一.前言 二.代码 三.使用 四.总结 一.前言 贪吃蛇游戏是一款经典的休闲益智类游戏，以下是关于该游戏的详细介绍： 游戏类型与平台：
阅读更多...
JAVA云his医院管理系统源码 SaaS模式+融合B/S版电子病历 基于云计算技术开发的云his医院管理系统

JAVA云his医院管理系统源码 SaaS模式+融合B/S版电子病历 基于云计算技术开发的云his医院管理系统

JAVA云his医院管理系统源码 SaaS模式融合B/S版电子病历 基于云计算技术开发的云his医院管理系统 定义 美国著名教授Morris.Collen于1988年曾著文为医院信息系统下了如下定义&#xff1a;利用电子计算机和通讯设备&#xff0c;为医院所属各部门提供病人诊疗信息和行政管理信息…
阅读更多...
FPGA相关论文阅读

FPGA相关论文阅读

一、Achieving 100Gbps Intrusion Prevention on a Single Server 论文名称中文翻译&#xff1a;在单台服务器上实现100Gbps吞吐量的入侵防御检测。 文章中的Mixed-1和Norm-1 二、Distributed Password Hash Computation on Commodity Heterogeneous Programmable Platforms…
阅读更多...
STM32学习-1 新建工程

STM32学习-1 新建工程

教学资料来自【STM32入门教程-2023版 细致讲解 中文字幕】 https://www.bilibili.com/video/BV1th411z7sn/?p5&share_sourcecopy_web&vd_sourcec6cfedd1c739ca8502f041514e158616 在keil中&#xff0c;每个代码最后一行必须是空的&#xff0c;不然运行会报错 配置库函…
阅读更多...
Failed to start tomcat.service: Unit is not loaded properly: Bad message 如何解决？

Failed to start tomcat.service: Unit is not loaded properly: Bad message 如何解决？

错误 “Failed to start tomcat.service: Unit is not loaded properly: Bad message” 通常意味着的 tomcat.service systemd 配置文件存在语法错误或配置不正确。为了解决这个问题&#xff0c;一步步检查和修正这个服务文件。 1. 检查 tomcat.service 文件 首先&#xff0c…
阅读更多...
免费泛域名证书申请

免费泛域名证书申请

通配符证书是一种 SSL/TLS 证书&#xff0c;可用于保护多个域&#xff08;主机&#xff09;&#xff0c;由域名字段中的通配符 (*) 指示。 如果您有很多需要保护的域或子域&#xff0c;这会很有帮助&#xff0c;因为它可以节省您的时间和金钱。 本文将讨论通配符证书、它们的工…
阅读更多...
【文献阅读】李井林等2021ESG促企业绩效的机制研究——基于企业创新的视角

【文献阅读】李井林等2021ESG促企业绩效的机制研究——基于企业创新的视角

ESG促进企业绩效的机制 摘要 0.引言与文献综述 1.理论分析与研究假设 1.1企业ESG表现与企业绩效 假设1a&#xff1a;企业的环境表现对企业绩效存在正向影响效应。 假设1b&#xff1a;企业的社会表现对企业绩效存在正向影响效应。 假设1c&#xff1a;企业的公司治理表现对企业…
阅读更多...
开放式耳机哪款具有高性价比？5款高分开放式耳机倾力推荐

开放式耳机哪款具有高性价比？5款高分开放式耳机倾力推荐

作为多年的耳机发烧友&#xff0c;强烈给你们安利开放式耳机&#xff0c;真的是舒适耐用&#xff0c;性价比高。开放式耳机以其独特的不入耳设计&#xff0c;给用户带来了最舒适的佩戴感受。如果小白还不知道怎么选择高性价比的开放式耳机那就看看我的总结吧&#xff01;下面就…
阅读更多...
Fast-Poisson-Image-Editing代码介绍（二）

Fast-Poisson-Image-Editing代码介绍（二）

目录 2.fpei文件下 2.6 number_solver.py 2.7 process.py 2.8 taichi_solver.py 3. 算法总结 4. 代码运行 4.1 测试 4.2 基于GUI后端自定义框输出编辑图像结果 4.2.1 下载open-cv 4.2.2 输入命令 4.2.3 自定义框 4.2.4 按ESC退出 接续Fast-Poisson-Image-Editing代码…
阅读更多...
MYSQL和JAVA中将中文汉字按照拼音首字母排序

MYSQL和JAVA中将中文汉字按照拼音首字母排序

一、MYSQL将中文汉字按照拼音首字母排序 数据库使用的字符编码是utf8_general_ci&#xff0c;如下 ORDER BY CONVERT(表名.字段名 USING gbk) COLLATE gbk_chinese_ci ASC;若是表查询&#xff0c;CONVERT中可以不添加表名。 查询结果如下&#xff1a; 二、JAVA中将中文汉字…
阅读更多...
最新文章

Copyright @ 2022~2023