【Java实战】低侵入的线程池值传递

news2025/6/3 1:02:56

欢迎来到啾啾的博客🐱。
记录学习点滴。分享工作思考和实用技巧，偶尔也分享一些杂谈💬。
有很多很多不足的地方，欢迎评论交流，感谢您的阅读和评论😄。

目录

  • 引言
  • InheritableThreadLocal
  • Alibaba TransmittableThreadLocal

引言

在之前的Java基础ThreadLocal篇章中，我们有了解到，ThreadLocal存储值线程安全的本质，是获取线程实例独享的的ThreadLocalMap属性。且k-v内容为this-value。在线程池复用线程的场景中，如果每次使用ThreadLocal存储值而不清除，线程的ThreadLocalMap将会持续扩容，直至内存溢出。
为此，我们需要在每次使用完ThreadLocal后进行remove操作。

但是在复杂场景中，我们可能忘记清理。
甚至在一些场景，我们希望主线程中ThreadLocal的值可以低侵入地传递到子线程中，比如如用于追踪请求调用链路的TraceID。

那么，我们应该怎么做呢？

InheritableThreadLocal

标准 ThreadLocal 的值不会自动从父线程传递到子线程。为此，Java 提供了 InheritableThreadLocal。
当你创建一个新线程时，子线程会自动继承父线程中 InheritableThreadLocal 变量的值。


public class TraceContext {
    private static final InheritableThreadLocal<String> TRACE_ID_HOLDER = new InheritableThreadLocal<>();

    public static void setTraceId(String traceId) {
        TRACE_ID_HOLDER.set(traceId);
    }

    public static String getTraceId() {
        return TRACE_ID_HOLDER.get();
    }

    public static void clearTraceId() {
        TRACE_ID_HOLDER.remove();
    }

    public static void main(String[] args) {
        // 主线程
        TraceContext.setTraceId("Main-thread-trace-id");
        new Thread(() -> {
            /*
             会打印 "main-thread-trace-id"
             注意：子线程修改不会影响父线程，父线程后续修改也不会影响已创建的子线程
             */
            System.out.println("Child thread traceId: " + TraceContext.getTraceId());
            TraceContext.setTraceId("child-thread-trace-id");
            System.out.println("Child thread traceId: " + TraceContext.getTraceId());
            TraceContext.clearTraceId(); // 最好也在子线程用完后清理
        }).start();
        // 主线程等待
        try {
            Thread.sleep(1000);
            System.out.println("Main thread traceId: " + TraceContext.getTraceId());
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            // 父线程也需要清理(通常在业务流程结束时清理)
            TraceContext.clearTraceId();
        }
        System.out.println("Main thread traceId: " + TraceContext.getTraceId());
    }
}

InheritableThreadLocal 的值是在子线程创建时从父线程复制的。
但是当使用是线程池时，InheritableThreadLocal有一个问题。
当一个任务提交给线程池，线程池复用一个已存在的线程时，这个被复用的线程不会从提交任务的当前线程那里重新继承 InheritableThreadLocal 的值。它会保留上一个任务结束时（或者它被创建时）的状态。
这会导致如果如果任务A在线程T1中设置了 InheritableThreadLocal 的值为 valA，任务A结束后没有清理。然后任务B（由不同的请求触发，期望的 InheritableThreadLocal 值为 valB）被分配到同一个线程T1，它会看到 valA 而不是期望的 valB。

InheritableThreadLocal解决了传递的问题，但是并不能解决自动处理的问题，还是不能“能够忘记清理”。


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

public class TraceContext {
    // 使用 InheritableThreadLocal
    private static final InheritableThreadLocal<String> TRACE_ID_HOLDER = new InheritableThreadLocal<>();

    public static void setTraceId(String traceId) {
        System.out.println("[" + Thread.currentThread().getName() + "] 设置 TraceID: " + traceId);
        TRACE_ID_HOLDER.set(traceId);
    }

    public static String getTraceId() {
        String traceId = TRACE_ID_HOLDER.get();
        // System.out.println("[" + Thread.currentThread().getName() + "] 获取 TraceID: " + traceId); // 频繁打印会比较乱
        return traceId;
    }

    public static void clearTraceId() {
        System.out.println("[" + Thread.currentThread().getName() + "] 清理 TraceID. 清理前的值: " + TRACE_ID_HOLDER.get());
        TRACE_ID_HOLDER.remove();
    }

    public static void main(String[] args) throws InterruptedException {
        // 创建一个单线程的线程池，方便观察线程复用
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        // ExecutorService executorService = Executors.newFixedThreadPool(1); // 等效
        System.out.println("===== 场景演示：InheritableThreadLocal 与线程池复用问题 =====");

        // --- 任务1：由主线程提交 ---
        // 主线程设置自己的 TraceID
        TraceContext.setTraceId("主线程-为任务1设置的TraceID");
        System.out.println("[" + Thread.currentThread().getName() + "] 准备提交任务1。主线程当前 TraceID: " + TraceContext.getTraceId());

        executorService.submit(() -> {
            String threadName = Thread.currentThread().getName();
            System.out.println("[" + threadName + "] 任务1开始执行。继承到的 TraceID: " + TraceContext.getTraceId());
            // 任务1 设置自己业务相关的 TraceID
            TraceContext.setTraceId("任务1特定的TraceID");
            System.out.println("[" + threadName + "] 任务1设置自身TraceID后。当前 TraceID: " + TraceContext.getTraceId());
            // 模拟任务执行
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            // 关键：任务1在结束前忘记清理自己设置的 TraceID
            System.out.println("[" + threadName + "] 任务1执行完毕。退出任务前 TraceID: " + TraceContext.getTraceId());
            // TraceContext.clearTraceId(); // <-- 如果这里调用了清理，任务2就不会看到脏数据
        });

        // 等待任务1执行完毕，确保线程已被“污染”
        Thread.sleep(200); // 确保任务1完成

        System.out.println("\n[" + Thread.currentThread().getName() + "] 任务1提交后，主线程的 TraceID (应保持不变): " + TraceContext.getTraceId());
        TraceContext.clearTraceId(); // 主线程清理自己的 TraceID ("主线程-为任务1设置的TraceID")
        System.out.println("[" + Thread.currentThread().getName() + "] 主线程清理自身TraceID后: " + TraceContext.getTraceId() + "\n");


        // --- 任务2：同样由主线程提交（此时主线程可能为任务2设置了新的TraceID） ---
        // 主线程为任务2的上下文设置新的 TraceID
        TraceContext.setTraceId("主线程-为任务2设置的TraceID");
        System.out.println("[" + Thread.currentThread().getName() + "] 准备提交任务2。主线程当前 TraceID: " + TraceContext.getTraceId());

        executorService.submit(() -> {
            String threadName = Thread.currentThread().getName();
            // 问题点：线程池线程（从任务1复用而来）仍然持有 "任务1特定的TraceID"
            // 它并不会从提交任务2的主线程那里继承 "主线程-为任务2设置的TraceID"
            System.out.println("[" + threadName + "] 任务2开始执行。继承到/残留的 TraceID: " + TraceContext.getTraceId() + " <<-- 问题点！这是任务1的残留，不是主线程为任务2设的值");

            // 如果任务2现在设置自己的ID，它会覆盖旧的脏数据
            TraceContext.setTraceId("任务2特定的TraceID");
            System.out.println("[" + threadName + "] 任务2设置自身TraceID后。当前 TraceID: " + TraceContext.getTraceId());
            // 模拟任务执行
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            // 任务2 正确地清理了它的 TraceID
            TraceContext.clearTraceId();
            System.out.println("[" + threadName + "] 任务2执行完毕。清理后 TraceID: " + TraceContext.getTraceId());
        });

        // 等待任务2执行完毕
        Thread.sleep(200);

        System.out.println("\n[" + Thread.currentThread().getName() + "] 任务2提交后，主线程的 TraceID (应保持不变): " + TraceContext.getTraceId());
        TraceContext.clearTraceId(); // 主线程清理自己的 TraceID ("主线程-为任务2设置的TraceID")

        executorService.shutdown();
        try {
            if (!executorService.awaitTermination(5, TimeUnit.SECONDS)) {
                executorService.shutdownNow();
            }
        } catch (InterruptedException e) {
            executorService.shutdownNow();
            Thread.currentThread().interrupt();
        }

        System.out.println("\n[" + Thread.currentThread().getName() + "] 主线程执行完毕。最终 TraceID: " + TraceContext.getTraceId());
        System.out.println("===== 场景演示结束 =====");
    }
}

Alibaba TransmittableThreadLocal

为了解决 InheritableThreadLocal 在线程池复用场景下的问题，通常的做法是：

  • 在父线程提交任务给线程池之前，获取父线程的 InheritableThreadLocal 上下文。
  • 包装 Runnable 或 Callable，使得在任务实际执行前（在线程池线程中），将捕获的上下文设置到当前“线程池线程”的 InheritableThreadLocal 中；任务执行完毕后，再清理掉。

Alibaba TransmittableThreadLocal（TTL）就是这样做的。它通过包装 Runnable, Callable, ExecutorService 等来实现上下文的正确传递和恢复。


import com.alibaba.ttl.TransmittableThreadLocal; // 引入TTL
import com.alibaba.ttl.threadpool.TtlExecutors; // 引入TtlExecutors (推荐方式)

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

public class TraceContextWithTTL {

    // 将 InheritableThreadLocal 替换为 TransmittableThreadLocal
    private static final TransmittableThreadLocal<String> TRACE_ID_HOLDER = new TransmittableThreadLocal<>();

    public static void setTraceId(String traceId) {
        System.out.println("[" + Thread.currentThread().getName() + "] 设置 TraceID: " + traceId);
        TRACE_ID_HOLDER.set(traceId);
    }

    public static String getTraceId() {
        String traceId = TRACE_ID_HOLDER.get();
        return traceId;
    }

    public static void clearTraceId() {
        System.out.println("[" + Thread.currentThread().getName() + "] 清理 TraceID. 清理前的值: " + TRACE_ID_HOLDER.get());
        TRACE_ID_HOLDER.remove();
    }

    public static void main(String[] args) throws InterruptedException {
        // 1. 创建一个普通的线程池
        ExecutorService originalExecutorService = Executors.newSingleThreadExecutor();

        // 2. 使用 TtlExecutors 包装原始线程池，使其支持TTL功能
        // 这样提交给 ttlExecutorService 的 Runnable/Callable 会被自动包装
        ExecutorService ttlExecutorService = TtlExecutors.getTtlExecutorService(originalExecutorService);

        System.out.println("===== 场景演示：TransmittableThreadLocal (TTL) 解决线程池复用问题 =====");

        // --- 任务1：由主线程提交 ---
        TraceContextWithTTL.setTraceId("主线程-为任务1设置的TraceID");
        System.out.println("[" + Thread.currentThread().getName() + "] 准备提交任务1。主线程当前 TraceID: " + TraceContextWithTTL.getTraceId());

        ttlExecutorService.submit(() -> { // 提交给包装后的 ttlExecutorService
            String threadName = Thread.currentThread().getName();
            // TTL 会确保这里能正确获取到父线程(main)在提交任务时设置的TraceID
            System.out.println("[" + threadName + "] 任务1开始执行。通过TTL获取到的 TraceID: " + TraceContextWithTTL.getTraceId());
            TraceContextWithTTL.setTraceId("任务1特定的TraceID");
            System.out.println("[" + threadName + "] 任务1设置自身TraceID后。当前 TraceID: " + TraceContextWithTTL.getTraceId());
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            // 任务1 仍然忘记清理 (用于演示TTL的上下文恢复能力)
            System.out.println("[" + threadName + "] 任务1执行完毕。退出任务前 TraceID: " + TraceContextWithTTL.getTraceId());
            // 即使这里没有 clearTraceId()，TTL 也会在任务执行后恢复线程池线程的原有TTL状态
        });

        Thread.sleep(200); // 确保任务1完成

        System.out.println("\n[" + Thread.currentThread().getName() + "] 任务1提交后，主线程的 TraceID (应保持不变): " + TraceContextWithTTL.getTraceId());
        TraceContextWithTTL.clearTraceId();
        System.out.println("[" + Thread.currentThread().getName() + "] 主线程清理自身TraceID后: " + TraceContextWithTTL.getTraceId() + "\n");

        // --- 任务2：同样由主线程提交 ---
        TraceContextWithTTL.setTraceId("主线程-为任务2设置的TraceID");
        System.out.println("[" + Thread.currentThread().getName() + "] 准备提交任务2。主线程当前 TraceID: " + TraceContextWithTTL.getTraceId());

        ttlExecutorService.submit(() -> { // 再次提交给包装后的 ttlExecutorService
            String threadName = Thread.currentThread().getName();
            // 关键点：即使任务1没有清理，TTL 也会确保任务2在开始时，
            // 其 TransmittableThreadLocal 的值是从提交任务2的父线程(main)那里正确传递过来的。
            // 不会再看到任务1残留的 "任务1特定的TraceID"。
            System.out.println("[" + threadName + "] 任务2开始执行。通过TTL获取到的 TraceID: " + TraceContextWithTTL.getTraceId() + " <<-- 正确！这是主线程为任务2设置的值");
            TraceContextWithTTL.setTraceId("任务2特定的TraceID");
            System.out.println("[" + threadName + "] 任务2设置自身TraceID后。当前 TraceID: " + TraceContextWithTTL.getTraceId());
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            TraceContextWithTTL.clearTraceId(); // 任务2 遵循良好实践，进行了清理
            System.out.println("[" + threadName + "] 任务2执行完毕。清理后 TraceID: " + TraceContextWithTTL.getTraceId());
        });

        Thread.sleep(200); // 确保任务2完成

        System.out.println("\n[" + Thread.currentThread().getName() + "] 任务2提交后，主线程的 TraceID (应保持不变): " + TraceContextWithTTL.getTraceId());
        TraceContextWithTTL.clearTraceId();

        // 关闭原始线程池 (TtlExecutors 包装的线程池会委托给原始线程池)
        originalExecutorService.shutdown();
        try {
            if (!originalExecutorService.awaitTermination(5, TimeUnit.SECONDS)) {
                originalExecutorService.shutdownNow();
            }
        } catch (InterruptedException e) {
            originalExecutorService.shutdownNow();
            Thread.currentThread().interrupt();
        }

        System.out.println("\n[" + Thread.currentThread().getName() + "] 主线程执行完毕。最终 TraceID: " + TraceContextWithTTL.getTraceId());
        System.out.println("===== 场景演示结束 =====");

        // 补充：如果不想包装 ExecutorService，也可以手动包装 Runnable/Callable
        // ExecutorService plainExecutor = Executors.newSingleThreadExecutor();
        // TraceContextWithTTL.setTraceId("Manually-Wrapped-TraceID");
        // Runnable originalRunnable = () -> {
        //     System.out.println("[" + Thread.currentThread().getName() + "] 手动包装的Runnable TraceID: " + TraceContextWithTTL.getTraceId());
        //     TraceContextWithTTL.clearTraceId();
        // };
        // Runnable ttlRunnable = TtlRunnable.get(originalRunnable); // 手动包装
        // plainExecutor.submit(ttlRunnable);
        // plainExecutor.shutdown();
        // plainExecutor.awaitTermination(1, TimeUnit.SECONDS);
        // TraceContextWithTTL.clearTraceId();
    }
}

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

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

相关文章

实验设计与分析（第6版，Montgomery)第5章析因设计引导5.7节思考题5.11 R语言解题

实验设计与分析（第6版，Montgomery)第5章析因设计引导5.7节思考题5.11 R语言解题

本文是实验设计与分析&#xff08;第6版&#xff0c;Montgomery著&#xff0c;傅珏生译) 第5章析因设计引导5.7节思考题5.11 R语言解题。主要涉及方差分析&#xff0c;正态假设检验&#xff0c;残差分析&#xff0c;交互作用图。 dataframe<-data.frame( densityc(570,565,…
阅读更多...
《软件工程》实战— 在线教育平台开发

《软件工程》实战— 在线教育平台开发

一、项目概述 1.1 项目背景与目标 随着教育数字化转型加速&#xff0c;传统教育模式逐渐向线上迁移&#xff0c;教育机构急需一个支持多终端访问、实时互动及高并发场景稳定运行的在线教育平台。本项目旨在构建学生、教师、管理员三位一体的协作教学环境&#xff0c;实现 50-2…
阅读更多...
iOS 使用CocoaPods 添加Alamofire 提示错误的问题

iOS 使用CocoaPods 添加Alamofire 提示错误的问题

Sandbox: rsync(59817) deny(1) file-write-create /Users/aaa/Library/Developer/Xcode/DerivedData/myApp-bpwnzikesjzmbadkbokxllvexrrl/Build/Products/Debug-iphoneos/myApp.app/Frameworks/Alamofire.framework/Alamofire.bundle把这个改成 no 2 设置配置文件
阅读更多...
Python打卡训练营学习记录Day41

Python打卡训练营学习记录Day41

DAY 41 简单CNN 知识回顾 数据增强卷积神经网络定义的写法batch归一化&#xff1a;调整一个批次的分布&#xff0c;常用与图像数据特征图&#xff1a;只有卷积操作输出的才叫特征图调度器&#xff1a;直接修改基础学习率 卷积操作常见流程如下&#xff1a; 1. 输入 → 卷积层 →…
阅读更多...
C++深入类与对象

C++深入类与对象

在上一篇中提到了构造函数&#xff0c;那么这篇再来提一下构造函数&#xff0c;编译器自动生成的默认构造函数对于内置类型不做处理&#xff0c;自定义类型会调用它自己的构造函数。对于自己写的构造函数&#xff0c;之前是在函数体中初始化&#xff0c;当然不止这一种初始化&a…
阅读更多...
阿里云服务器邮件发送失败（dail tcp xxxx:25: i/o timeout）因为阿里云默认禁用 25 端口

阿里云服务器邮件发送失败（dail tcp xxxx:25: i/o timeout）因为阿里云默认禁用 25 端口

最近在测试发送邮件的功能&#xff0c;发现了一个奇怪的问题&#xff0c;同样的 docker 镜像&#xff0c;在本地跑起来是可以正常发送邮件的&#xff0c;但是在阿里云的服务器上跑&#xff0c;就会报错 i/o timeout。 排查了一圈发现&#xff0c;原来是阿里云的操作&#xff0…
阅读更多...
力扣HOT100之动态规划：322. 零钱兑换

力扣HOT100之动态规划：322. 零钱兑换

这道题和上一道题279.完全平方数的套路是完全一样的&#xff0c;但是这道题不需要我们自己生成物品列表&#xff0c;函数的输入中已经给出了&#xff0c;但是这道题有一个坑&#xff0c;就是我们在初始化dp数组的时候&#xff0c;所有的位置不应该赋值为INT_MAX&#xff0c;因为…
阅读更多...
电商售后服务系统与其他系统集成：实现售后流程自动化

电商售后服务系统与其他系统集成：实现售后流程自动化

在竞争激烈的电商市场中&#xff0c;优质的售后服务对于提升用户满意度和忠诚度至关重要。然而&#xff0c;售后服务流程通常涉及多个环节和系统&#xff0c;如何高效地管理这些流程&#xff0c;减少人工干预&#xff0c;提升服务效率&#xff0c;是电商企业亟待解决的问题。电…
阅读更多...
kafka学习笔记（三、消费者Consumer使用教程——消费性能多线程提升思考）

kafka学习笔记（三、消费者Consumer使用教程——消费性能多线程提升思考）

1.简介 KafkaConsumer是非线程安全的&#xff0c;它定义了一个acquire()方法来检测当前是否只有一个线程在操作&#xff0c;如不是则会抛出ConcurrentModifcationException异常。 acquire()可以看做是一个轻量级锁&#xff0c;它仅通过线程操作计数标记的方式来检测线程是否发…
阅读更多...
[JVM] JVM内存调优

[JVM] JVM内存调优

&#x1f338;个人主页:https://blog.csdn.net/2301_80050796?spm1000.2115.3001.5343 &#x1f3f5;️热门专栏: &#x1f9ca; Java基本语法(97平均质量分)https://blog.csdn.net/2301_80050796/category_12615970.html?spm1001.2014.3001.5482 &#x1f355; Collection与…
阅读更多...
秒出PPT正式改名秒出AI，开启AI赋能新体验！

秒出PPT正式改名秒出AI，开启AI赋能新体验！

在现代办公环境中&#xff0c;借助智能工具提升工作效率已经成为趋势。秒出AI作为一款集AI PPT制作、动画、巨幕、视频、设计以及智能简历功能于一体的综合办公平台&#xff0c;为用户提供一站式智能内容生成解决方案&#xff0c;极大地简化了内容创作流程。 1. AI驱动的一键P…
阅读更多...
VM改MAC电脑密码（截图）

VM改MAC电脑密码（截图）

进入恢复模式重置密码 重启mac并同时按下CommandR&#xff0c;进入恢复模式。进入「菜单栏-实用程序-终端」&#xff0c;输入命令「resetpassword」回车运行&#xff0c;调出密码重置工具。选择包含密码的启动磁盘卷宗、需重设密码的用户账户&#xff1b;输入并确认新的用户密…
阅读更多...
SpringBoot+Vue+微信小程序校园自助打印系统

SpringBoot+Vue+微信小程序校园自助打印系统

概述​​ 校园自助打印系统是现代化校园建设中不可或缺的一部分&#xff0c;基于SpringBootVue微信小程序开发的​​免费Java源码​​项目&#xff0c;包含完整的用户预约、打印店管理等功能模块。 ​​主要内容​​ ​​ 系统功能模块​​ ​​登录验证模块​​&#xff1a;…
阅读更多...
【论文精读】2024 CVPR--Upscale-A-Video现实世界视频超分辨率(RealWorld VSR)

【论文精读】2024 CVPR--Upscale-A-Video现实世界视频超分辨率(RealWorld VSR)

文章目录 一、摘要二、挑战三、Method3.1 前置知识3.1.1 预训练SD 4 Upscaler3.1.2 Inflated 2D Convolution 扩展2D卷积 3.2 Local Consistency within Video Segments 视频片段中的一致性3.2.1 微调时序U-Net3.2.2 微调时序VAE-Decoder 3.3 跨片段的全局一致性 Global Consis…
阅读更多...
学术合作交流

学术合作交流

想找志同道合的科研小伙伴&#xff01;研究方向包括&#xff1a;计算机视觉&#xff08;CV&#xff09;、人工智能&#xff08;AI&#xff09;、目标检测、行人重识别、行人搜索、虹膜识别等。欢迎具备扎实基础的本科、硕士及博士生加入&#xff0c;共同致力于高质量 SCI 期刊和…
阅读更多...
【LUT技术专题】图像自适应3DLUT

【LUT技术专题】图像自适应3DLUT

3DLUT开山之作: Learning Image-adaptive 3D Lookup Tables for High Performance Photo Enhancement in Real-time&#xff08;2020 TPAMI &#xff09; 专题介绍一、研究背景二、图像自适应3DLUT方法2.1 前置知识2.2 整体流程2.3 损失函数的设计 三、实验结果四、局限五、总结…
阅读更多...
德拜温度热容推导

德拜温度热容推导

目录 一、背景与基本假设 一、态密度的定义 二、从波矢空间出发 三、振动模式数与波矢体积关系 四、模式总数计算 五、态密度求导 六、德拜频率确定与归一化条件 二、内能表达式的推导 三、态密度代入与变量替换 四、求比热容 五、低温时&#xff08;&#xff09; …
阅读更多...
【iOS】源码阅读(五)——类类的结构分析

【iOS】源码阅读(五)——类类的结构分析

文章目录 前言类的分析类的本质objc_class 、objc_object和NSObjectobjc_object&#xff1a;所有对象的基类型objc_class&#xff1a;类的底层结构NSObject&#xff1a;面向用户的根类 小结 指针内存偏移普通指针----值拷贝对象----指针拷贝或引用拷贝用数组指针引出----内存偏…
阅读更多...
基于CangjieMagic的RAG技术赋能智能问答系统

基于CangjieMagic的RAG技术赋能智能问答系统

目录 引言 示例程序分析 代码结构剖析 导入模块解读 智能体配置详情 提示词模板说明 主程序功能解析 异步聊天功能实现 检索信息展示 技术要点总结 ollama 本地部署nomic-embed-text 运行测试 结语 引言 这段时间一直在学习CangjieMagic。前几天完成了在CangjieMa…
阅读更多...
算力租赁革命：弹性模式如何重构数字时代的创新门槛​

算力租赁革命：弹性模式如何重构数字时代的创新门槛​

一、算力革命&#xff1a;第四次工业革命的核心驱动力​ 在科技飞速发展的当下&#xff0c;我们正悄然迎来第四次工业革命。华为创始人任正非在一场程序设计竞赛中曾深刻指出&#xff0c;这场革命的基础便是大算力。随着 5G、人工智能、大数据、物联网等信息技术的迅猛发展&am…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023