Java进阶版线程池（超详细 ）

news2025/7/15 16:53:15

线程池 

线程池工具类  Executors 

Executors 是 Java 提供的一个工具类，它包含了多个静态方法，能够方便地创建不同类型的线程池。        

newFixedThreadPool

创建一个固定大小的线程池，线程池中的线程数量固定，当有新任务提交时，如果线程池中有空闲线程，则立即执行任务；如果没有空闲线程，则将任务放入工作队列等待。

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

public class FixedThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个固定大小为 3 的线程池
        ExecutorService executor = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 5; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println("Task " + taskId + " is being executed by " + Thread.currentThread().getName());
            });
        }
        executor.shutdown();
    }
}
newSingleThreadExecutor

创建一个单线程的线程池，线程池只有一个线程，所有任务按顺序依次执行。

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

public class SingleThreadExecutorExample {
    public static void main(String[] args) {
        // 创建一个单线程的线程池
        ExecutorService executor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 5; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println("Task " + taskId + " is being executed by " + Thread.currentThread().getName());
            });
        }
        executor.shutdown();
    }
}
 newCachedThreadPool

创建一个可缓存的线程池，线程池的线程数量不固定，当有新任务提交时，如果线程池中有空闲线程，则立即执行任务；如果没有空闲线程，则创建新线程来执行任务。当线程空闲时间超过 60 秒时，会被销毁。

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

public class CachedThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个可缓存的线程池
        ExecutorService executor = Executors.newCachedThreadPool();
        for (int i = 0; i < 5; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println("Task " + taskId + " is being executed by " + Thread.currentThread().getName());
            });
        }
        executor.shutdown();
    }
}
newScheduledThreadPool

创建一个支持定时和周期性任务执行的线程池。

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

public class ScheduledThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个大小为 2 的定时线程池
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);
        // 延迟 2 秒后执行任务
        executor.schedule(() -> System.out.println("Scheduled task executed"), 2, TimeUnit.SECONDS);
        // 延迟 1 秒后开始，每 3 秒执行一次任务
        executor.scheduleAtFixedRate(() -> System.out.println("Periodic task executed"), 1, 3, TimeUnit.SECONDS);
        executor.shutdown();
    }
}

自定义线程池：ThreadPoolExecutor 

常用构造函数如下：

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

参数含义如下：

  1. corePoolSize：核心线程数。线程池会保持这些线程一直存活，即便它们处于空闲状态。当有新任务提交时，若线程池里的线程数量少于 corePoolSize，就会创建新线程来处理任务。
  2. maximumPoolSize：线程池允许的最大线程数。当工作队列已满，并且线程池中的线程数量小于 maximumPoolSize 时，会创建新线程来处理任务。
  3. keepAliveTime：线程空闲时的存活时间。当线程池中的线程数量超过 corePoolSize，且这些多余的线程空闲时间达到 keepAliveTime 时，它们会被销毁。
  4. unit：keepAliveTime 的时间单位，它是 TimeUnit 枚举类型，例如 TimeUnit.SECONDS、TimeUnit.MILLISECONDS 等。
  5. workQueue：用于存储待执行任务的阻塞队列。常见的队列类型有 ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue 等。
  6. threadFactory：线程工厂，用于创建线程。通过自定义线程工厂，可以为线程设置名称、优先级等属性。
  7. handler：拒绝策略，当工作队列已满且线程池中的线程数量达到 maximumPoolSize 时，新提交的任务会被拒绝，此时会调用该策略来处理被拒绝的任务。常见的拒绝策略有 AbortPolicy、CallerRunsPolicy、DiscardPolicy、DiscardOldestPolicy 等。

CompletableFuture

CompletableFuture 是 Java 8 引入的一个类，位于 java.util.concurrent 包中。它是用于异步编程的工具类，表示一个异步任务的未来结果。CompletableFuture 提供了丰富的 API，用于处理异步任务的完成、组合和异常处理。

CompletableFuture 与 Thread 和 Runnable 的区别

Thread 和 Runnable

   Thread：是 Java 中最基本的线程类，用于创建和管理线程。它提供了线程的基本功能，但不支持异步编程和结果处理。

   Runnable：是一个接口，表示一个可以被线程执行的任务。它通常与 Thread 一起使用，但同样不支持异步编程和结果处理。

        缺点：Thread和Runnable都是在run()中写多线程代码，二者都没有返回值（可以使用轮询和回调）。

        CompletableFuture的出现解决了这个问题，它支持下面功能：

  • 支持异步编程，可以创建异步任务并处理其结果。

  • 链式调用：支持链式调用，可以将多个异步任务组合在一起，形成一个完整的流程。

  • 异常处理：提供了丰富的异常处理机制，可以捕获和处理异步任务中的异常。

  • 组合操作：可以组合多个异步任务，例如 allOf() 和 anyOf()，并等待它们完成。

实例：

 Supplier<String> mm1 = new Supplier<String>() {
            @Override
            public String get() {
                for(int i=0;i<10;i++){
                    System.out.println("1111111111");
                }
                return "第一个";
            }
        };
        CompletableFuture<String> dd1 = CompletableFuture.supplyAsync(mm1);
        Supplier<String> mm2 = new Supplier<String>() {
            @Override
            public String get() {
                for(int i=0;i<10;i++){
                    System.out.println("2222222222222");
                }
                return "第二个";
            }
        };
        CompletableFuture<String> dd2 = CompletableFuture.supplyAsync(mm2);
        Supplier<String> mm3 =()->{         //Lambda表达式（匿名函数）

              for(int i=0;i<100;i++){
                    System.out.println("3333333333");
                }
                return "第三个";
        };
//        Supplier<String> mm3 = new Supplier<String>() {
//            @Override
//            public String get() {
//                for(int i=0;i<100;i++){
//                    System.out.println("3333333333");
//                }
//                return "第三个";
//            }
//        };
        CompletableFuture<String> dd3 = CompletableFuture.supplyAsync(mm3);
        CompletableFuture<Void> vo = CompletableFuture.allOf(dd1, dd2, dd3);
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println(dd1.join()+"--------"+dd2.join()+"--------"+dd3.join());
            }
        };
        vo.thenRun(r);
        vo.join();

  CompletableFuture的重要API：

  • CompletableFuture.runAsync(Runnable runnable)
    • 此方法用于异步执行一个 Runnable 任务，没有返回值。它会使用 ForkJoinPool.commonPool() 作为线程池来执行任务。
    • 示例代码：
import java.util.concurrent.CompletableFuture;

public class RunAsyncExample {
    public static void main(String[] args) {
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            System.out.println("Running task asynchronously");
        });
        future.join();
    }
}

  • CompletableFuture.runAsync(Runnable runnable, Executor executor)
    • 与上面的方法类似，但可以指定一个自定义的 Executor 来执行任务（没有返回值）。
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class RunAsyncWithExecutorExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            System.out.println("Running task asynchronously with custom executor");
        }, executor);
        future.join();
        executor.shutdown();
    }
}

  • CompletableFuture.supplyAsync(Supplier<U> supplier)
    • 异步执行一个 Supplier 任务，有返回值。同样使用 ForkJoinPool.commonPool() 作为线程池。
    • 示例代码：
import java.util.concurrent.CompletableFuture;

public class SupplyAsyncExample {
    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            return "Result from asynchronous task";
        });
        String result = future.join();
        System.out.println(result);
    }
}

  • CompletableFuture.supplyAsync(Supplier<U> supplier, Executor executor)
    • 与 supplyAsync(Supplier<U> supplier) 类似，可指定自定义的 Executor 来执行任务。

2. 处理任务结果

  • thenApply(Function<? super T,? extends U> fn)
    • 当 CompletableFuture 完成后，对结果进行转换。返回一个新的 CompletableFuture，其结果是原 CompletableFuture 结果经过 Function 处理后的结果。
    • 示例代码：
import java.util.concurrent.CompletableFuture;

public class ThenApplyExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 5);
        CompletableFuture<Integer> newFuture = future.thenApply(num -> num * 2);
        Integer result = newFuture.join();
        System.out.println(result);
    }
}

  • thenAccept(Consumer<? super T> action)
    • 当 CompletableFuture 完成后，对结果进行消费，没有返回值。
    • 示例代码：
import java.util.concurrent.CompletableFuture;

public class ThenAcceptExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 10);
        future.thenAccept(num -> System.out.println("Received result: " + num));
    }
}

  • thenRun(Runnable action)
    • 当 CompletableFuture 完成后，执行一个 Runnable 任务，不关心原 CompletableFuture 的结果。
    • 示例代码：
import java.util.concurrent.CompletableFuture;

public class ThenRunExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 20);
        future.thenRun(() -> System.out.println("Task completed"));
    }
}

3. 组合多个 CompletableFuture

  • thenCompose(Function<? super T, ? extends CompletionStage<U>> fn)
    • 用于组合两个 CompletableFuture，前一个 CompletableFuture 的结果作为后一个 CompletableFuture 的输入。
    • 示例代码：
import java.util.concurrent.CompletableFuture;

public class ThenComposeExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 3);
        CompletableFuture<Integer> future2 = future1.thenCompose(num -> CompletableFuture.supplyAsync(() -> num * 4));
        Integer result = future2.join();
        System.out.println(result);
    }
}

  • thenCombine(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn)
    • 当两个 CompletableFuture 都完成后，将它们的结果组合起来。
    • 示例代码：
import java.util.concurrent.CompletableFuture;

public class ThenCombineExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 2);
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 3);
        CompletableFuture<Integer> combinedFuture = future1.thenCombine(future2, (num1, num2) -> num1 + num2);
        Integer result = combinedFuture.join();
        System.out.println(result);
    }
}

4. 异常处理

  • exceptionally(Function<Throwable, ? extends T> fn)
    • 当 CompletableFuture 出现异常时，使用 Function 处理异常并返回一个默认值。
    • 示例代码：
import java.util.concurrent.CompletableFuture;

public class ExceptionallyExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            if (Math.random() < 0.5) {
                throw new RuntimeException("Something went wrong");
            }
            return 10;
        });
        CompletableFuture<Integer> resultFuture = future.exceptionally(ex -> {
            System.out.println("Caught exception: " + ex.getMessage());
            return 0;
        });
        Integer result = resultFuture.join();
        System.out.println("Final result: " + result);
    }
}

  • handle(BiFunction<? super T, Throwable, ? extends U> fn)
    • 无论 CompletableFuture 是否完成或出现异常，都会执行 BiFunction，可以根据是否有异常来处理结果。
    • 示例代码：
import java.util.concurrent.CompletableFuture;

public class HandleExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            if (Math.random() < 0.5) {
                throw new RuntimeException("Something went wrong");
            }
            return 20;
        });
        CompletableFuture<Integer> resultFuture = future.handle((result, ex) -> {
            if (ex != null) {
                System.out.println("Caught exception: " + ex.getMessage());
                return 0;
            }
            return result;
        });
        Integer result = resultFuture.join();
        System.out.println("Final result: " + result);
    }
}

5. 等待多个 CompletableFuture 完成

  • CompletableFuture.allOf(CompletableFuture<?>... cfs)
    • 等待所有给定的 CompletableFuture 都完成。返回一个新的 CompletableFuture，当所有输入的 CompletableFuture 都完成时，这个新的 CompletableFuture 也完成。
    • 示例代码：
import java.util.concurrent.CompletableFuture;

public class AllOfExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 1);
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 2);
        CompletableFuture<Integer> future3 = CompletableFuture.supplyAsync(() -> 3);

        CompletableFuture<Void> allFutures = CompletableFuture.allOf(future1, future2, future3);
        allFutures.join();

        Integer result1 = future1.join();
        Integer result2 = future2.join();
        Integer result3 = future3.join();
        System.out.println("Results: " + result1 + ", " + result2 + ", " + result3);
    }
}

  • CompletableFuture.anyOf(CompletableFuture<?>... cfs)
    • 只要有一个给定的 CompletableFuture 完成，就返回一个新的 CompletableFuture，其结果是第一个完成的 CompletableFuture 的结果。
    • 示例代码：
import java.util.concurrent.CompletableFuture;

public class AnyOfExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 1;
        });
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 2);

        CompletableFuture<Object> anyFuture = CompletableFuture.anyOf(future1, future2);
        Object result = anyFuture.join();
        System.out.println("First completed result: " + result);
    }
}

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

YOLOv11训练中精准率召回率与mAP@0.5的动态变化分析

YOLOv11训练中精准率召回率与mAP@0.5的动态变化分析

目标检测模型的训练过程涉及多个关键性能指标和损失函数的变化&#xff0c;这些数据能够直观反映模型的收敛速度、最终精度以及改进效果。本文旨在通过绘制YOLOv11模型在训练过程中的精准率&#xff08;Precision&#xff09;、召回率&#xff08;Recall&#xff09;、mAP0.5 、…
阅读更多...
Java常用工具算法-6--秘钥托管云服务AWS KMS

Java常用工具算法-6--秘钥托管云服务AWS KMS

前言&#xff1a; 之前我们介绍了一些常用的加密算法&#xff08;如&#xff1a;对称加密AES&#xff0c;非对称加密RSA&#xff0c;ECC等&#xff09;&#xff0c;不论是哪一种都需要涉及到秘钥的管理。通常的做法都是把秘钥放到配置文件中进行配置&#xff0c;但是对于一些高…
阅读更多...
11. Langchain输出解析（Output Parsers）：从自由文本到结构化数据

11. Langchain输出解析（Output Parsers）：从自由文本到结构化数据

引言&#xff1a;从"自由发挥"到"规整输出" 2025年某金融机构的合同分析系统升级前&#xff0c;AI生成的合同摘要需人工二次处理达47分钟/份。引入LangChain结构化解析后&#xff0c;处理时间缩短至3分钟。本文将详解如何用LangChain的解析器&#xff0c;…
阅读更多...
python reportlab模块----操作PDF文件

python reportlab模块----操作PDF文件

reportlab模块----操作PDF文件 一. 安装模块二. reportlab相关介绍三. 扩展canvas类四. 水平写入完整代码五. 垂直写入完整代码 一. 安装模块 pip install reportlab二. reportlab相关介绍 # 1. letter 生成A4纸张尺寸 from reportlab.lib.pagesizes import letter print(let…
阅读更多...
解锁基因密码之重测序（从测序到分析）

解锁基因密码之重测序（从测序到分析）

在生命科学的奇妙世界中&#xff0c;基因恰似一本记录着生命奥秘的“天书”&#xff0c;它承载着生物体生长、发育、衰老乃至疾病等一切生命现象的关键信息。而重测序技术&#xff0c;则是开启基因“天书”奥秘的一把神奇钥匙。 试想&#xff0c;你手中有一本经典书籍的通用版…
阅读更多...
TQTT_KU5P开发板教程---QSFP25G光口回环测试

TQTT_KU5P开发板教程---QSFP25G光口回环测试

文档实现功能介绍 本文档通过一个叫做ibert的IP&#xff0c;实现25G光口回环测试例子。工程新建方法请参考文档《流水灯》&#xff0c;其中只是将文件名进行修改。 Vivado 起始页&#xff08;或 file-->Project-->New 创建新工程(Create New Project) 向导起始页面 点…
阅读更多...
JVM虚拟机篇（七）：JVM垃圾回收器全面解析与G1深度探秘及四种引用详解

JVM虚拟机篇（七）：JVM垃圾回收器全面解析与G1深度探秘及四种引用详解

JVM垃圾回收器全面解析与G1深度探秘及四种引用详解 JVM虚拟机&#xff08;七&#xff09;&#xff1a;JVM垃圾回收器全面解析与G1深度探秘及四种引用详解一、JVM有哪些垃圾回收器1. Serial回收器2. ParNew回收器3. Parallel Scavenge回收器4. Serial Old回收器5. Parallel Old回…
阅读更多...
柑橘病虫害图像分类数据集OrangeFruitDaatset-8600

柑橘病虫害图像分类数据集OrangeFruitDaatset-8600

文章目录 1. 前言2. 数据类别介绍3. 数据集地址 1. 前言 柑橘&#xff0c;作为水果界的 “宠儿”&#xff0c;不仅以其酸甜可口的味道深受大众喜爱&#xff0c;更是在全球水果产业中占据着举足轻重的地位。无论是早餐中的一杯橙汁&#xff0c;还是下午茶里的柑橘甜点&#xff…
阅读更多...
深度学习总结（4）

深度学习总结（4）

张量积 张量积&#xff08;tensor product&#xff09;或点积&#xff08;dot product&#xff09;是最常见且最有用的张量运算之一。注意&#xff0c;不要将其与逐元素乘积&#xff08;*运算符&#xff09;弄混。在NumPy中&#xff0c;使用np.dot函数来实现张量积&#xff0c…
阅读更多...
利用CST Microwave Studio设计贴片天线

利用CST Microwave Studio设计贴片天线

利用CST Microwave Studio设计贴片天线的步骤如下&#xff0c;分为几个关键阶段&#xff1a; --- ### **1. 初始设置** - **新建项目**&#xff1a;打开CST&#xff0c;创建新项目&#xff08;File > New&#xff09;&#xff0c;选择“Antenna (Planar)”或“Microwave &…
阅读更多...
STM32之SG90舵机控制（附视频讲解）

STM32之SG90舵机控制（附视频讲解）

目录 前言&#xff1a; 一、硬件准备与接线 1.1 硬件清单 1.2 接线 二、 SG90舵机简介 1.1 外观 1.2 基本参数 1.3 引脚说明 1.4 控制原理 1.5 特点 1.6 常见问题 三、 单片机简介 四、 程序设计 4.1 定时器配置 4.2 角度控制函数 4.3 主函数调用 五、 总结 …
阅读更多...
（1）英特尔 RealSense T265（三）

（1）英特尔 RealSense T265（三）

文章目录 前言 4.4 地面测试 4.5 飞行测试 4.6 室内外实验 4.7 数据闪存记录 4.8 启动时自动运行 4.9 使用 OpticalFlow 进行 EKF3 光源转换 前言 Realsense T265 通过 librealsense 支持 Windows 和 Linux 系统。不同系统的安装过程差异很大&#xff0c;因此请参阅 gi…
阅读更多...
多模态大语言模型arxiv论文略读（七）

多模态大语言模型arxiv论文略读（七）

MLLM-DataEngine: An Iterative Refinement Approach for MLLM ➡️ 论文标题&#xff1a;MLLM-DataEngine: An Iterative Refinement Approach for MLLM ➡️ 论文作者&#xff1a;Zhiyuan Zhao, Linke Ouyang, Bin Wang, Siyuan Huang, Pan Zhang, Xiaoyi Dong, Jiaqi Wang,…
阅读更多...
SQL ③-基本语法

SQL ③-基本语法

SQL基本语法 表操作 创建表 CREATE TABLE table_name (column1 datatype constraint,column2 datatype constraint,column3 datatype constraint,... );删除表 DROP [TEMPORARY] TABLE [IF EXISTS] table_name [, table_name...];TEMPORARY&#xff1a;表示临时表&#xff…
阅读更多...
esp32cam -＞ 服务器 | 手机 -＞ 服务器 直接服务器传输图片

esp32cam -＞ 服务器 | 手机 -＞ 服务器 直接服务器传输图片

服务器先下载python &#xff1a; 一、Python环境搭建&#xff08;CentOS/Ubuntu通用&#xff09; 一条一条执行 安装基础依赖 # CentOS sudo yum install gcc openssl-devel bzip2-devel libffi-devel zlib-devel # Ubuntu sudo apt update && sudo apt install b…
阅读更多...
豆浆机语音提示芯片方案：基于可远程在线更换语音的WT2003H-16S芯片

豆浆机语音提示芯片方案：基于可远程在线更换语音的WT2003H-16S芯片

随着智能家居概念的普及&#xff0c;消费者对家电产品的智能化、便捷性提出了更高要求。豆浆机作为厨房常用电器&#xff0c;其操作便捷性和用户体验直接影响市场竞争力。传统豆浆机多依赖指示灯或简单蜂鸣器提示用户操作状态&#xff0c;信息传递单一且无法满足个性化需求。 在…
阅读更多...
解密工业控制柜：认识关键硬件（PLC）

解密工业控制柜：认识关键硬件（PLC）

前言 作为一名视觉开发工程师&#xff0c;我们不仅要做到做好自己的工作&#xff0c;我们更需要在工业现场学习更多知识&#xff0c;最近网上流传很多&#xff0c;“教会徒弟&#xff0c;饿死师傅”&#xff1b;在自动化行业中&#xff0c;在项目下来很忙的时候&#xff0c;我们…
阅读更多...
【嵌入式系统设计师】知识点：第11 章 嵌入式系统设计案例分析

【嵌入式系统设计师】知识点：第11 章 嵌入式系统设计案例分析

提示：“软考通关秘籍” 专栏围绕软考展开，全面涵盖了如嵌入式系统设计师、数据库系统工程师、信息系统管理工程师等多个软考方向的知识点。从计算机体系结构、存储系统等基础知识，到程序语言概述、算法、数据库技术（包括关系数据库、非关系型数据库、SQL 语言、数据仓库等）…
阅读更多...
【深度解析】SkyWalking 10.2.0版本安全优化与性能提升实战指南

【深度解析】SkyWalking 10.2.0版本安全优化与性能提升实战指南

前言 Apache SkyWalking 作为云原生可观测性领域的佼佼者&#xff0c;在微服务架构监控中扮演着至关重要的角色。然而&#xff0c;官方版本在安全性、镜像体积和功能扩展方面仍有优化空间。本文将分享一套完整的 SkyWalking 10.2.0 版本优化方案&#xff0c;从安全漏洞修复到镜…
阅读更多...
面向大模型的开发框架LangChain

面向大模型的开发框架LangChain

这篇文章会带给你 如何使用 LangChain&#xff1a;一套在大模型能力上封装的工具框架如何用几行代码实现一个复杂的 AI 应用面向大模型的流程开发的过程抽象 文章目录 这篇文章会带给你写在前面LangChain 的核心组件文档&#xff08;以 Python 版为例&#xff09;模型 I/O 封装…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023