【多线程】线程池核心数到底如何配置？

🥰🥰🥰来都来了，不妨点个关注叭！
👉博客主页：欢迎各位大佬!👈

在这里插入图片描述

文章目录

  • 1. 前置回顾
  • 2. 动态线程池
    • 2.1 JMX 的介绍
      • 2.1.1 MBeans 介绍
    • 2.2 使用 JMX + jconsole 实现动态修改线程池
      • 2.2.1 介绍 ManagementFactory
      • 2.2.2 JMX 与 ManagementFactory 的区别与联系

回顾这期内容:【多线程】线程池，介绍了线程池，其中 5.3 介绍如何给线程池设置合适线程数量（这期内容会再回顾一遍），这期内容，具体讨论一下，线程池核心数到底如何配置~

1. 前置回顾

在实际开发中如何给线程池设置合适的线程数量呢？

我们要知道，线程不是越多越好，线程的本质上是要在 CPU 上调度的，一个线程池的线程数量设置为多少合适，这需要结合实际情况实际任务决定，一般分为 CPU 密集型和 IO 密集型，通常是如下配置：

  1. CPU 密集型任务：N+1，主要做一些计算工作，要在 CPU上运行
  2. IO 密集型任务：2N+1，主要是等待 IO 操作，比如等待读写硬盘，读写网卡等，不怎么消耗 CPU 资源
    (其中 N 为 CPU 的核心数量)

Q：为什么要加 1

A：+1 个线程是为了在某个线程因为一些原因，比如缓存未命中、遇到短暂的指令停顿等，暂时阻塞时，能有一个额外的线程可以在 CPU 上运行，从而充分利用 CPU 的空闲时间，避免 CPU 核心出现空闲等待的情况，提高整体的 CPU 利用率，应对一些特殊情况或系统开销等，确保即使在某些线程出现意外阻塞等情况时，系统仍能有额外的线程来维持一定的处理能力，保证系统的稳定性和性能

极端情况下，如果线程全是使用 CPU 运行，线程数就不应该超过 CPU 核心数（逻辑核心，比如一个电脑是6核12线程，即12个逻辑核心，以12为基准），如果线程全是使用的 IO，则线程数可以设置很多，远远超出 CPU 的核心数

在实际开发中，很少有这么极端的情况，就是以实际情况来设定，需要具体通过测试的方式来确定，测试方式的大体思路是，运行程序，通过记录时间戳计算一下执行时间，同时监测资源的使用状态，线程数量取一个执行效率可以并且占用资源也还可以的数量~

这里的两个关键点：

  • 记录时间戳计算执行时间
  • 监测资源的使用状态

计算执行时间的具体操作方法是，可以统计一个完整的请求中，耗费 CPU 计算的过程占用了多少时间，等待的过程，如读取缓存、读取 DB 等占用了多少时间，假设统计结果是 100ms 用来做 CPU 计算，900ms 都是 IO 相关的操作，不占 CPU 时间，那么就可以通过 (100+900) / 100 的计算公式，得出对于单核 CPU，设置线程数为 10 就可以把 CPU 跑满，同理，如果是 6 核 CPU，那么就设置线程数为 60

监测资源的使用状态具体操作方法，在程序执行过程中，持续监测 CPU、内存、线程等资源的使用情况

具体代码如下：

import java.lang.management.ManagementFactory;
import java.lang.management.OperatingSystemMXBean;
import java.lang.management.ThreadMXBean;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ResourceMonitoringExample {

    // 这里进行模拟任务
    static class Task implements Runnable {
        @Override
        public void run() {
            try {
                // 模拟耗时操作
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        int threadCount = 10; // 初始线程数量
        ExecutorService executor = Executors.newFixedThreadPool(threadCount);

        // 记录开始时间
        long startTime = System.currentTimeMillis();

        // 提交任务
        for (int i = 0; i < 20; i++) {
            executor.submit(new Task());
        }

        // 关闭线程池
        executor.shutdown();
        while (!executor.isTerminated()) {
            // 监测资源使用状态
            monitorResources();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 记录结束时间
        long endTime = System.currentTimeMillis();
        long executionTime = endTime - startTime;
        System.out.printf("程序执行时间: %d 毫秒%n", executionTime);
    }

    // 监测资源使用状态
    private static void monitorResources() {
        // 监测 CPU 使用情况
        OperatingSystemMXBean osBean = ManagementFactory.getOperatingSystemMXBean();
        if (osBean instanceof com.sun.management.OperatingSystemMXBean) {
            com.sun.management.OperatingSystemMXBean sunOsBean = (com.sun.management.OperatingSystemMXBean) osBean;
            double cpuLoad = sunOsBean.getSystemCpuLoad();
            if (cpuLoad >= 0) {
                System.out.printf("当前系统 CPU 使用率: %.2f%%%n", cpuLoad * 100);
            }
        }

        // 监测线程数量
        ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
        int threadCount = threadBean.getThreadCount();
        System.out.printf("当前活动线程数量: %d%n", threadCount);
    }
}

其中：ManagementFactory 是 Java 中的一个实用工具类，位于 java.lang.management 包下，该类提供了一系列静态方法，用于获取 JVM 的各种管理接口实例，这些管理接口允许你监控和管理 JVM 的运行时状态、系统资源使用情况等（后文会详细介绍）~

总结：

线程池的核心参数并不是这么冰冷冷且固定的数字，还是需要结合实际场景考虑，一般线程池核心数，可以根据实际情况进行计算后配置~

下面介绍动态线程池，我们一起来看看~

2. 动态线程池

线程池线程数的设置是个难题，线程池核心数到底如何配置？最好的办法是能够动态调整线程池线程数，并能够看到调整后的效果，也就是线程利用率，有一个工具能够实现这样的效果 —— 使用 JMX

那么 JMX 是什么呢？ 我们先来一起了解一下！

2.1 JMX 的介绍

  1. JMX 是什么：JMX（Java Management Extensions）是 Java 平台的一部分，它提供了一种管理和监控 Java 应用程序的标准方法，即是一个为应用程序、设备、系统等植入管理功能的框架，JMX 允许监控和管理系统资源、应用程序和服务，以及获取关于这些实体的运行时信息，简单来说，就是通过 JMX 可以动态查看对象的运行信息，并且可以动态修改对象属性~
  2. JMX 的架构：如下图
    在这里插入图片描述

分析这张图我们可以发现，JMX 底层是由很多不同的 MBeans 组成的，即 MBeans 是 JMX 的核心

2.1.1 MBeans 介绍

MBeans 是什么：它们是实现了特定接口的 Java 对象，用于表示可以被监控和管理的资源

MBeans 的类型：可以分为四种不同的类型

  • Standard MBeans
  • Dynamic MBeans
  • Open MBeans
  • Model MBeans

MBeans 的作用：这些 MBeans 的作用就是获取对象的信息，或是修改对象信息，都是通过 MBeans 来完成的

MBeans 的用法：所有的 MBeans 都需要注册到 MBeanServer 上，然后再通过一些外部工具如 JMX、Web 浏览器等，就可以去获取或者修改 MBeans 的信息了

补充：
Q：那 MBean Server 是什么呢？
A：这里的 MBean Server 是一个代理，它提供一个注册、检索和操作 MBeans 的 API，它是 JMX 架构中的核心组件，负责管理所有 MBeans 的生命周期

接下来，我们一起来看看如何使用 JMX 诗仙女动态修改线程池

2.2 使用 JMX + jconsole 实现动态修改线程池

1）自定义一个动态线程池

首先，我们先来自定义一个动态线程池，如下：

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 26727
 * Date: 2025-02-05
 * Time: 18:41
 */
public class DynamicThreadPool {
    private ThreadPoolExecutor threadPoolExecutor;

    public DynamicThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        threadPoolExecutor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }

    public ThreadPoolExecutor getThreadPoolExecutor() {
        return threadPoolExecutor;
    }

    public void setCorePoolSize(int corePoolSize) {
        threadPoolExecutor.setCorePoolSize(corePoolSize);
    }

    public void setMaximumPoolSize(int maximumPoolSize) {
        threadPoolExecutor.setMaximumPoolSize(maximumPoolSize);
    }
}

动态线程池的相关参数如下，动态线程池其实就是传统的线程传统的线程池对象 ThreadPoolExecutor 封装了一下，并且提供了两个方法 setCorePoolSize 和 setMaximumPoolSize，这样通过这两个方法，我们就可以动态设置线程池的线程数了~

在这里插入图片描述

2）自定义一个 MBean 接口

接下来，我们自定义一个 MBean 这个接口中提供四个方法，分别用来获取或者设置线程数的信息

public interface DynamicThreadPoolMXBean {
    int getCorePoolSize();
    void setCorePoolSize(int corePoolSize);
    int getMaximumPoolSize();
    void setMaximumPoolSize(int maximumPoolSize);
}

3）自定义类实现 DynamicThreadPoolMXBean 接口

接着，我们自定义类实现 DynamicThreadPoolMXBean 接口，并继承 StandardMBean 类，如下：

import javax.management.MBeanServer;
import javax.management.ObjectName;
import javax.management.StandardMBean;
import java.lang.management.ManagementFactory;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 26727
 * Date: 2025-02-04
 * Time: 23:02
 */
public class DynamicThreadPoolMBean extends StandardMBean implements DynamicThreadPoolMXBean {

    private DynamicThreadPool dynamicThreadPool;

    public DynamicThreadPoolMBean(DynamicThreadPool dynamicThreadPool) throws Exception {
        super(DynamicThreadPoolMXBean.class);
        this.dynamicThreadPool = dynamicThreadPool;
        registerMBean();
    }

    private void registerMBean() {
        try {
            MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
            ObjectName name = new ObjectName("org.javaboy:type=DynamicThreadPool");
            mbs.registerMBean(this, name);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public int getCorePoolSize() {
        return dynamicThreadPool.getThreadPoolExecutor().getCorePoolSize();
    }

    @Override
    public void setCorePoolSize(int corePoolSize) {
        dynamicThreadPool.setCorePoolSize(corePoolSize);
    }

    @Override
    public int getMaximumPoolSize() {
        return dynamicThreadPool.getThreadPoolExecutor().getMaximumPoolSize();
    }

    @Override
    public void setMaximumPoolSize(int maximumPoolSize) {
        dynamicThreadPool.setMaximumPoolSize(maximumPoolSize);
    }
}

【解析】

  • 构造函数接受一个 DynamicThreadPool 类型的参数，用于初始化 dynamicThreadPool 的成员变量
    super(DynamicThreadPoolMXBean.class) 调用父类 StandardMBean 的构造函数，传入 DynamicThreadPoolMXBean 类的 Class 对象，用于指定 MBean 的管理接口，调用 registerMBean() 方法将该 MBean 注册到 JMX 平台 MBean 服务器中，即在构造器中，调用了 registerMBean() 方法，这个方法用来将当前对象注册到 MBeanServer 上~

  • 注册 MBean 方法 registerMBean()，ManagementFactory.getPlatformMBeanServer() 获取平台 MBean 服务器的实例，ObjectName 用于唯一标识 MBean，这里使用 org.javaboy:type=DynamicThreadPool 作为 MBean 的名称，
    mbs.registerMBean(this, name) 将当前 DynamicThreadPoolMBean 实例注册到 MBean 服务器中

4）执行代码

最后，就可以启动自己的这段代码了~

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 26727
 * Date: 2025-02-04
 * Time: 23:07
 */
public class Main {
    public static void main(String[] args) throws Exception {
        DynamicThreadPool dynamicThreadPool = new DynamicThreadPool(2, 6, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(10));
        DynamicThreadPoolMBean mBean = new DynamicThreadPoolMBean(dynamicThreadPool);

        while (true) {
            System.out.println("CorePoolSize:"+dynamicThreadPool.getThreadPoolExecutor().getCorePoolSize());
            System.out.println("MaximumPoolSize:"+dynamicThreadPool.getThreadPoolExecutor().getMaximumPoolSize());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

为了看到线程池的线程数量，这里使用了一个死循环一直打印线程数量信息，这样一会通过 jconsole 修改线程池信息的时候，就能看到修改的效果了~

程序启动之后，使用 jconsole 连接上当前应用程序，如下图：

（jconsole 使用忘记的小伙伴可回顾往期内容：【多线程】如何使用jconsole工具查看Java线程的详细信息？）

点击 Main 进入连接

在这里插入图片描述
点击 MBean 这个选项卡位置，可以看到刚刚配置的 MBean，右侧的值则可以点击直接修改，修改之后，回到应用程序控制台，可以发现线程相关数据已经发生变化了，实现了动态修改的效果~

在这里插入图片描述
可以看到，控制台信息已经发生变化，如下：

在这里插入图片描述
这样就可以动态修改了！

2.2.1 介绍 ManagementFactory

可以看到上面使用了 ManagementFactory 类，下面具体介绍其用法：

1） 获取线程管理接口实例 —— getThreadMXBean()

返回一个 ThreadMXBean 实例，用于监控和管理 Java 虚拟机中的线程，通过该接口，可以获取线程的各种信息，如线程的状态、CPU 时间、阻塞时间等

import java.lang.management.ManagementFactory;
import java.lang.management.ThreadMXBean;

public class ThreadMonitoringExample {
    public static void main(String[] args) {
        // 获取 ThreadMXBean 实例
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
        // 获取所有线程的 ID
        long[] threadIds = threadMXBean.getAllThreadIds();
        for (long threadId : threadIds) {
            // 获取线程信息
            System.out.println("Thread ID: " + threadId + ", Thread Name: " + threadMXBean.getThreadInfo(threadId).getThreadName());
        }
    }
}

2）获取内存管理接口实例 —— getMemoryMXBean()

返回一个 MemoryMXBean 实例，用于监控和管理 Java 虚拟机的内存使用情况。通过该接口，可以获取堆内存和非堆内存的使用情况，还可以触发垃圾回收操作~

import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;
import java.lang.management.MemoryUsage;

public class MemoryMonitoringExample {
    public static void main(String[] args) {
        // 获取 MemoryMXBean 实例
        MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
        // 获取堆内存使用情况
        MemoryUsage heapMemoryUsage = memoryMXBean.getHeapMemoryUsage();
        System.out.println("Heap Memory Usage: " + heapMemoryUsage);
        // 获取非堆内存使用情况
        MemoryUsage nonHeapMemoryUsage = memoryMXBean.getNonHeapMemoryUsage();
        System.out.println("Non-Heap Memory Usage: " + nonHeapMemoryUsage);
    }
}

3）获取运行时管理接口实例 —— getRuntimeMXBean()

返回一个 RuntimeMXBean 实例，用于获取 Java 虚拟机的运行时信息，如 JVM 的启动时间、系统属性、命令行参数等

import java.lang.management.ManagementFactory;
import java.lang.management.RuntimeMXBean;

public class RuntimeInfoExample {
    public static void main(String[] args) {
        // 获取 RuntimeMXBean 实例
        RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
        // 获取 JVM 启动时间
        long startTime = runtimeMXBean.getStartTime();
        System.out.println("JVM Start Time: " + startTime);
        // 获取系统属性
        System.out.println("System Properties: " + runtimeMXBean.getSystemProperties());
    }
}

ManagementFactory 类为 Java 开发者提供了便捷的方式来监控和管理 JVM 的运行时状态，通过获取不同的管理接口实例，可以深入了解 JVM 的内部运行情况，从而进行性能调优、故障排查等相关工作~

2.2.2 JMX 与 ManagementFactory 的区别与联系

区别：

JMX —— Java 扩展管理，是一个为应用程序、设备、系统等植入管理功能的框架

ManagementFactory —— Java 标准库中用于辅助使用 JMX 功能的实用工具类

联系：

  • ManagementFactory 是 JMX 功能使用的便捷入口
    JMX 架构复杂：JMX 定义了一套完整的架构，包括 MBean、MBeanServer等核心组件，使用 JMX 进行管理和监控时，需要涉及多个步骤和类的使用，整体较为复杂，而 ManagementFactory 简化操作，ManagementFactory 类提供了一系列静态方法，通过调用这些方法可以方便地获取各种 JMX 管理接口的实例。如，ManagementFactory.getThreadMXBean() 方法返回的 ThreadMXBean 是一个 JMX 的 MXBean，它允许开发者监控和管理 Java 虚拟机中的线程。这些方法隐藏了底层 JMX 架构的复杂性，使得开发者可以更轻松地使用 JMX 功能~
  • ManagementFactory 实例基于 JMX 标准
    ManagementFactory 所返回的各种管理接口实例（如 MemoryMXBean、RuntimeMXBean 等）都是遵循 JMX 规范的 MXBean，这些 MXBean 定义了一组标准的管理操作和属性，可以通过 JMX 代理进行访问和管理，并且可集成到 JMX 系统，通过 ManagementFactory 获取的管理接口实例可以无缝集成到 JMX 系统中。开发者可以将这些 MXBean 注册到 MBeanServer 上，然后使用 JMX 客户端远程或本地监控和管理 Java 应用程序~
  • ManagementFactory 服务于 JMX 监控和管理目的
    支持监控：JMX 的主要目的之一是对 Java 应用程序进行监控和管理，ManagementFactory 所提供的各种管理接口实例可以提供丰富的监控数据，例如，MemoryMXBean 可以提供 Java 虚拟机的内存使用情况，包括堆内存和非堆内存的使用量、峰值等信息；并且ThreadMXBean 可以提供线程的状态、CPU 时间等信息。
    支持管理：除了监控数据，ManagementFactory 所提供的管理接口实例还支持一些管理操作，例如，MemoryMXBean 可以触发垃圾回收操作，ThreadMXBean 可以获取线程的堆栈跟踪信息等，这些操作可以帮助开发者对 Java 应用程序进行动态管理和故障排查~

在这里插入图片描述

💛💛💛本期内容回顾💛💛💛

在这里插入图片描述

✨✨✨本期内容到此结束啦~

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

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

相关文章

js-对象-JSON

js-对象-JSON

JavaScript自定义对象 JSON 概念: JavaScript Object Notation&#xff0c;JavaScript对象标记法. JSON 是通过JavaScript 对象标记法书写的文本。 由于其语法简单&#xff0c;层次结构鲜明&#xff0c;现多用于作为数据载体&#xff0c;在网络中进行数据传输. json中属性名(k…
阅读更多...
基于 SpringBoot3 的 SpringSecurity6 + OAuth2 自定义框架模板

基于 SpringBoot3 的 SpringSecurity6 + OAuth2 自定义框架模板

&#x1f516;Gitee 项目地址&#xff1a; 基于SpringBoot3的 SpringSecurity6 OAuth2 自定义框架https://gitee.com/MIMIDeK/MySpringSecurityhttps://gitee.com/MIMIDeK/MySpringSecurityhttps://gitee.com/MIMIDeK/MySpringSecurity
阅读更多...
大模型综述一镜到底（全文八万字） ——《Large Language Models: A Survey》

大模型综述一镜到底（全文八万字） ——《Large Language Models: A Survey》

论文链接&#xff1a;https://arxiv.org/abs/2402.06196 摘要&#xff1a;自2022年11月ChatGPT发布以来&#xff0c;大语言模型&#xff08;LLMs&#xff09;因其在广泛的自然语言任务上的强大性能而备受关注。正如缩放定律所预测的那样&#xff0c;大语言模型通过在大量文本数…
阅读更多...
Django视图与URLs路由详解

Django视图与URLs路由详解

在Django Web框架中&#xff0c;视图&#xff08;Views&#xff09;和URLs路由&#xff08;URL routing&#xff09;是Web应用开发的核心概念。它们共同负责将用户的请求映射到相应的Python函数&#xff0c;并返回适当的响应。本篇博客将深入探讨Django的视图和URLs路由系统&am…
阅读更多...
位置-速度双闭环PID控制详解与C语言实现

位置-速度双闭环PID控制详解与C语言实现

目录 概述 1 控制架构解析 1.1 级联控制结构 1.2 性能对比 2 数学模型 2.1 位置环(外环) 2.2 速度环(内环) 3 C语言完整实现 3.1 控制结构体定义 3.2 初始化函数 3.3 双环计算函数 4 参数整定指南 4.1 整定步骤 4.2 典型参数范围 5 关键优化技术 5.1 速度前馈 …
阅读更多...
亚博microros小车-原生ubuntu支持系列：22 物体识别追踪

亚博microros小车-原生ubuntu支持系列：22 物体识别追踪

背景知识 跟上一个颜色追踪类似。也是基于opencv的&#xff0c;不过背后的算法有很多 BOOSTING&#xff1a;算法原理类似于Haar cascades (AdaBoost)&#xff0c;是一种很老的算法。这个算法速度慢并且不是很准。MIL&#xff1a;比BOOSTING准一点。KCF&#xff1a;速度比BOOST…
阅读更多...
低至3折，百度智能云千帆宣布全面支持DeepSeek-R1/V3调用

低至3折，百度智能云千帆宣布全面支持DeepSeek-R1/V3调用

DeepSeek-R1和 DeepSeek-V3模型已在百度智能云千帆平台上架 。 出品|产业家 新年伊始&#xff0c;百度智能云又传来新动作 。 2月3日百度智能云宣布&#xff0c; DeepSeek-R1和 DeepSeek-V3模型已在百度智能云千帆平台上架&#xff0c;同步推出超低价格方案&#xff0c;并…
阅读更多...
Deepseek技术浅析（四）：专家选择与推理机制

Deepseek技术浅析（四）：专家选择与推理机制

DeepSeek 是一种基于**专家混合模型&#xff08;Mixture of Experts, MoE&#xff09;**的先进深度学习架构&#xff0c;旨在通过动态选择和组合多个专家网络&#xff08;Expert Networks&#xff09;来处理复杂的任务。其核心思想是根据输入数据的特征&#xff0c;动态激活最合…
阅读更多...
go运算符

go运算符

内置运算符 算术运算符关系运算符逻辑运算符位运算符赋值运算符 算术运算符 注意&#xff1a; &#xff08;自增&#xff09;和–&#xff08;自减&#xff09;在 Go 语言中是单独的语句&#xff0c;并不是运算符 package mainimport "fmt"func main() {fmt.Printl…
阅读更多...
分享2款 .NET 开源且强大的翻译工具

分享2款 .NET 开源且强大的翻译工具

前言 对于程序员而言永远都无法逃避和英文打交道&#xff0c;今天大姚给大家分享2款 .NET 开源、功能强大的翻译工具&#xff0c;希望可以帮助到有需要的同学。 STranslate STranslate是一款由WPF开源的、免费的&#xff08;MIT License&#xff09;、即开即用、即用即走的翻…
阅读更多...
技术书籍写作与编辑沟通指南

技术书籍写作与编辑沟通指南

引言 撰写技术书籍不仅仅是知识的输出过程&#xff0c;更是与编辑团队紧密合作的协同工作。优秀的技术书籍不仅依赖作者深厚的技术背景&#xff0c;还需要精准的表达、流畅的结构以及符合出版要求的编辑润色。因此&#xff0c;如何高效地与编辑沟通&#xff0c;确保书籍质量&a…
阅读更多...
Linux中系统相关指令(一)

Linux中系统相关指令(一)

一、时间查看指令date 1.1时间显示的格式 1> 默认格式&#xff0c;直接输入&#xff1a; date 回车 会直接展示出来&#xff0c;如&#xff1a; 2> 常用格式&#xff1a;年-月-日 时&#xff1a;分&#xff1a;秒 这种格式更加贴近于我们的习惯&#xff0c;但需要…
阅读更多...
C语言：深入了解指针3

C语言：深入了解指针3

1.回调函数是什么&#xff1f; 基本概念 回调函数就是⼀个通过函数指针调⽤的函数。 如果你把函数的指针&#xff08;地址&#xff09;作为参数传递给另⼀个函数&#xff0c;当这个指针被⽤来调⽤其所指向的函数 时&#xff0c;被调⽤的函数就是回调函数。回调函数不是由该函…
阅读更多...
【Uniapp-Vue3】创建DB schema数据表结构

【Uniapp-Vue3】创建DB schema数据表结构

右键uniCloud文件下的database文件&#xff0c;点击“新建DB schema”&#xff0c;选择模板&#xff0c;修改文件名&#xff0c;点击“创建” 创建完成后会出现对应的文件&#xff0c;进入该文件进行配置 对文件中的必填选项&#xff0c;用户权限&#xff0c;字段进行配置 其…
阅读更多...
Java基础进阶-水仙花数

Java基础进阶-水仙花数

/* 功能&#xff1a;求水仙花数&#xff0c;打印并统计总个数。 思路&#xff1a; 水仙花数是定义范围100-999&#xff0c;满足每个位上的数子的3次方相加和等于这个数 第一步&#xff1a;循环遍历数据范围 第二步&#xff1b;取出当前数字的个位&#xff0c;十位&#xff0c;百…
阅读更多...
DDD - 领域事件_解耦微服务的关键

DDD - 领域事件_解耦微服务的关键

文章目录 Pre领域事件的核心概念领域事件的作用领域事件的识别领域事件的技术实现领域事件的运行机制案例领域事件驱动的优势 Pre DDD - 微服务设计与领域驱动设计实战(中)_ 解决微服务拆分难题 EDA - Spring Boot构建基于事件驱动的消息系统 领域事件的核心概念 领域事件&a…
阅读更多...
MacBook Pro（M1芯片）Qt环境配置

MacBook Pro（M1芯片）Qt环境配置

MacBook Pro&#xff08;M1芯片&#xff09;Qt环境配置 1、准备 试图写一个跨平台的桌面应用&#xff0c;此时想到了使用Qt&#xff0c;于是开始了搭建开发环境&#xff5e; 在M1芯片的电脑上安装&#xff0c;使用brew工具比较方便 Apple Silicon&#xff08;ARM/M1&#xf…
阅读更多...
简单本地部署deepseek（软件版）

简单本地部署deepseek（软件版）

Download Ollama on Windows 下载 下载安装 winr 输入 cmd 然后输入ollama -v&#xff0c;出现ollama版本&#xff0c;安装成功 deepseek-r1 选择1.5b 输入 cmd 下面代码 ollama run deepseek-r1:1.5b 删除deepseek的代码如下&#xff1a; ollama rm deepseek-r1:1.5b 使用…
阅读更多...
Linux生成自签证书【Nginx】

Linux生成自签证书【Nginx】

&#x1f468;‍&#x1f393;博主简介 &#x1f3c5;CSDN博客专家   &#x1f3c5;云计算领域优质创作者   &#x1f3c5;华为云开发者社区专家博主   &#x1f3c5;阿里云开发者社区专家博主 &#x1f48a;交流社区&#xff1a;运维交流社区 欢迎大家的加入&#xff01…
阅读更多...
Docker基础以及单体实战

Docker基础以及单体实战

Docker 一、Docker1.1 Docker组成1.2 Dcoker运行图1.3 名称空间Namepace 1.4 docker、Docker compose、kubermetes 二、Docker安装2.1 在线Docker安装2.2 使用官方通用安装脚本2.3 二进制安装Docker三、Docker基础命令3.1 启动类3.2 镜像类3.3 容器类3.4 网络类3.5 Docker comp…
阅读更多...
最新文章

Copyright @ 2022~2023