Tokio 任务泄露检测:用 tokio-console 和 metrics 找到“僵尸任务“

Linux 音频驱动(六) ALSA音频驱动之PCM Write数据传递过程 目录1. 前言2. PCM Data Flow3. 总结 1. 前言 本文,我们将以回放(Playback,播放音频)为例,讲解PCM Data是如何从用户空间到内核空间,最后传递到Codec。 在Linux 音频驱动(一) ASoC音频框架简介中,我们给出了回放(Playback)PCM数据流示意图: 对于Linux来说,由于分为 user space 和kernel space,而且两者之间不能随便互相访问。因此用户如果播放音频,则需要调用copy_from_user()将用户数据从user spa 阅读详情

Tokio 任务泄露检测:用 tokio-console 和 metrics 找到"僵尸任务"

这就是我今天要聊的:Tokio 任务泄露。它不是传统意义上的内存泄露,但后果一样严重——资源耗尽、响应变慢、最终 OOM。更坑的是,Rust 编译器帮不了你,因为从编译器的视角,这些代码完全正确。今天我会分享我是怎么用 tokio-console 和 metrics 来检测和解决这类问题的。

一、任务泄露是怎么发生的

先写一个最常见的泄露场景:一个 WebSocket 服务,每个连接 spawn 一个读写任务。但因为一个隐蔽的逻辑 bug,连接断开后任务没有退出。

use tokio::net::{TcpListener, TcpStream};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::sync::mpsc;

/// 最典型泄露场景:WebSocket 连接处理
/// 每个连接 spawn 两个任务,但退出条件有 bug
async fn handle_connection(mut socket: TcpStream) {
    // mpsc channel:读任务把收到的消息发到写任务
    let (tx, mut rx) = mpsc::channel::<String>(32);  // ← 注意:容量 32
    let (mut read_half, mut write_half) = socket.split();

    // 读任务:从 socket 读数据
    let read_task = tokio::spawn(async move {
        let mut buf = vec![0u8; 1024];
        loop {
            match read_half.read(&mut buf).await {
                Ok(0) => {
                    // 连接关闭了(对端发了 FIN)
                    println!("连接关闭,读任务退出");
                    break;
                }
                Ok(n) => {
                    let msg = String::from_utf8_lossy(&buf[..n]).to_string();
                    // BUG在这里!如果 channel 满了,send 会阻塞等待
                    // 但发送端永远不会被唤醒,任务永远卡在这里
                    if tx.send(msg).await.is_err() {
                        break;  // ← 只有接收端关闭才会走这里
                    }
                }
                Err(e) => {
                    eprintln!("读错误: {}", e);
                    break;
                }
            }
        }
    });

    // 写任务:把收到的消息写回 socket
    let write_task = tokio::spawn(async move {
        while let Some(msg) = rx.recv().await {
            if write_half.write_all(msg.as_bytes()).await.is_err() {
                break;
            }
        }
        println!("写任务退出");
    });

    // 等待任一任务完成(正常情况读任务退出后写任务也会退出)
    tokio::select! {
        _ = read_task => {}
        _ = write_task => {}
    }
}

表面看这段代码没问题,但实际上有一个经典的死锁泄露:

  • 读任务往 channel 发消息,channel 容量只有 32
  • 写任务消费消息,但如果写任务来不及消费(比如网络慢),channel 满了
  • 读任务卡在 tx.send(msg).await 上,永远等不到 slot
  • 但写任务也在等读任务发消息——互相等待,谁也没退出

这就是一个"僵尸任务"——它没有崩,runtime 认为它还在正常运行,但实际上它什么有用的事也不做,就是占着内存。

二、用 tokio-console 可视化任务状态

tokio-console 是 Tokio 官方出的一个实时监控工具,能让你看到 runtime 里有多少任务在跑、每个任务在做什么、在哪个 .await 点卡住了。

使用起来很简单,三步走:

第一步:在 Cargo.toml 加依赖:

[dependencies]
tokio = { version = "1", features = ["full", "tracing"] }
console-subscriber = "0.4"

第二步:初始化 console subscriber:

/// 在 main 函数最开头初始化
/// console_subscriber 会启动一个 gRPC 服务,供 tokio-console 连接
#[tokio::main]
async fn main() {
    // init() 必须在任何 tokio 任务 spawn 之前调用
    console_subscriber::init();
    
    // 正常启动你的应用...
    let listener = TcpListener::bind("0.0.0.0:8080").await.unwrap();
    loop {
        let (socket, _) = listener.accept().await.unwrap();
        tokio::spawn(handle_connection(socket));
    }
}

第三步:在另一个终端运行 tokio-console:

# 安装 tokio-console(只需要装一次)
cargo install tokio-console

# 运行
tokio-console

启动后你会看到一个类似 htop 的 TUI 界面。左侧是任务列表,每一项显示了任务 ID、名称、状态(RUNNING / IDLE / BLOCKING)、已运行时间、以及当前的 poll 次数。右侧是任务详情,显示任务卡在哪个文件的哪一行。

stateDiagram-v2
    [*] --> spawned: tokio::spawn()
    
    state "Tokio Runtime" as Runtime {
        spawned --> poll_start: runtime 调度
        
        state poll_start {
            [*] --> executing: poll() 开始
            executing --> awaiting: .await 遇到未就绪的 Future
            awaiting --> waker_registered: 返回 Poll::Pending
            waker_registered --> [*]: 进等待队列
        }
        
        waker_registered --> poll_start: IO 就绪, waker 唤醒
        executing --> completed: 返回 Poll::Ready
    }
    
    completed --> [*]: 任务结束
    
    note right of awaiting
        如果 waker 永远不会被触发
        → 任务永远停在 awaiting
        → 这就是【僵尸任务】
    end note

tokio-console 的威力在于,你可以直观地看到:某个任务运行了 30 秒了还在 IDLE 状态,总 poll 次数只有 5 次,说明它大部分时间在等(可能是等着错误的 waker)。正常任务应该是频繁地在 RUNNING 和 IDLE 之间切换。

三、用 metrics 建立任务泄露的告警机制

tokio-console 适合调试和手动排查,但要防止线上出问题,需要在代码里埋点,用 metrics 做持续监控。

use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::Arc;
use tokio::sync::Semaphore;

/// 全局任务计数器
/// 用 AtomicU64 保证无锁的增删操作
#[derive(Clone)]
struct TaskMetrics {
    /// 当前活跃任务数(spawn 时 +1,任务退出时 -1)
    active_tasks: Arc<AtomicU64>,
    /// 历史累计创建的任务数
    total_spawned: Arc<AtomicU64>,
    /// 历史累计退出的任务数
    total_completed: Arc<AtomicU64>,
}

impl TaskMetrics {
    fn new() -> Self {
        TaskMetrics {
            active_tasks: Arc::new(AtomicU64::new(0)),
            total_spawned: Arc::new(AtomicU64::new(0)),
            total_completed: Arc::new(AtomicU64::new(0)),
        }
    }

    fn spawn_guard(&self) -> TaskGuard {
        // 创建新任务时:活跃数+1,累计+1
        self.active_tasks.fetch_add(1, Ordering::Relaxed);
        self.total_spawned.fetch_add(1, Ordering::Relaxed);
        TaskGuard { metrics: self.clone() }
    }

    fn snapshot(&self) -> TaskSnapshot {
        TaskSnapshot {
            active: self.active_tasks.load(Ordering::Relaxed),
            spawned: self.total_spawned.load(Ordering::Relaxed),
            completed: self.total_completed.load(Ordering::Relaxed),
        }
    }
}

/// RAII 守卫:任务退出时自动减活跃数
struct TaskGuard {
    metrics: TaskMetrics,
}

impl Drop for TaskGuard {
    fn drop(&mut self) {
        // 任务结束,活跃数-1,完成数+1
        self.metrics.active_tasks.fetch_sub(1, Ordering::Relaxed);
        self.metrics.total_completed.fetch_add(1, Ordering::Relaxed);
    }
}

/// 封装 spawn:自动记录 metrics
fn spawn_tracked<F>(metrics: &TaskMetrics, name: &str, future: F)
where
    F: std::future::Future<Output = ()> + Send + 'static,
{
    let guard = metrics.spawn_guard();
    let name = name.to_string();
    tokio::spawn(async move {
        // ⚠️ 关键:把 guard move 进 async 块
        // 这样任务退出时(async 块结束),guard 的 Drop 会被调用
        let _guard = guard;
        tracing::info!(task_name = %name, "任务开始");
        future.await;
        tracing::info!(task_name = %name, "任务退出");
    });
}

/// 定期打印 metrics,用于发现泄露趋势
async fn metrics_reporter(metrics: TaskMetrics) {
    let mut interval = tokio::time::interval(
        std::time::Duration::from_secs(10)
    );
    loop {
        interval.tick().await;
        let snap = metrics.snapshot();
        tracing::info!(
            active = snap.active,
            spawned = snap.spawned,
            completed = snap.completed,
            delta = snap.spawned.saturating_sub(snap.completed),
            "任务 metrics"
        );
        
        // 告警规则:如果 spawned - completed 持续上涨
        // 且 active_tasks 一直在增长 → 大概率有任务泄露
        if snap.active > 1000 {
            tracing::error!(
                active_tasks = snap.active,
                "⚠️ 活跃任务数超过 1000,可能存在任务泄露!"
            );
        }
    }
}

核心思路就是用 RAII:TaskGuard 在创建时 +1,在 Drop 时 -1。只要把 guard move 进 tokio::spawn 的闭包里,任务退出时自动减。如果 spawned 和 completed 的差距越来越大,就说明有任务没有正常退出。

四、根因修复模式:从发现到修复的三步法

找到泄露后怎么修复?我总结了三步法:

第一步:确保取消安全(Cancellation Safety)。很多泄露是因为 select! 中一个分支被 drop 了但另一个分支没有收到取消信号。修复方式是给 channel 的发送端设置超时:

/// 修复版:用 try_send + 超时 替代 send
async fn safe_send<T>(tx: &mpsc::Sender<T>, msg: T) -> Result<(), T> {
    // try_send 不会阻塞,满了直接返回
    match tx.try_send(msg) {
        Ok(()) => Ok(()),
        Err(mpsc::error::TrySendError::Full(msg)) => {
            // channel 满了,等 100ms 再试
            tokio::time::sleep(std::time::Duration::from_millis(100)).await;
            // 再试一次,还不行就丢弃
            if tx.try_send(msg).is_err() {
                tracing::warn!("消息丢弃:channel 持续满");
            }
            Ok(())
        }
        Err(mpsc::error::TrySendError::Closed(_)) => {
            // 接收端已关闭,正常返回
            Ok(())
        }
    }
}

第二步:join 相关联的任务。如果一个任务衍生出子任务,应该在退出前 join 所有子任务,而不是"用完就忘":

/// 用 JoinSet 管理一组相关任务
/// 确保父任务退出前,所有子任务都被等待
async fn managed_connection(socket: TcpStream) {
    let mut tasks = tokio::task::JoinSet::new();

    // spawn 进 JoinSet,而不是裸 tokio::spawn
    tasks.spawn(read_loop(socket));
    tasks.spawn(write_loop(socket));
    tasks.spawn(heartbeat_timer());

    // 等待任一任务出错
    while let Some(result) = tasks.join_next().await {
        match result {
            Ok(()) => {
                tracing::info!("一个子任务正常退出");
            }
            Err(e) => {
                tracing::error!("子任务 panic: {}", e);
                // 一个子任务出错 → 停止所有子任务
                tasks.abort_all();
                break;
            }
        }
    }
    
    // 确保所有子任务都已退出
    while (tasks.join_next().await).is_some() {}
    tracing::info!("所有子任务已清理完毕");
}

第三步:加上全局超时。不确定的死循环最危险,给每个任务加一个保底超时:

/// 给任务加上兜底超时
async fn spawn_with_timeout<F>(future: F, timeout_duration: std::time::Duration)
where
    F: std::future::Future<Output = ()> + Send + 'static,
{
    tokio::spawn(async move {
        match tokio::time::timeout(timeout_duration, future).await {
            Ok(()) => {
                tracing::info!("任务正常完成");
            }
            Err(_elapsed) => {
                tracing::error!(
                    duration_secs = timeout_duration.as_secs(),
                    "⏰ 任务超时,强制退出!"
                );
                // 超时后这里的 async 块结束,任务被清理
            }
        }
    });
}
flowchart TD
    A["发现可疑:活跃任务数持续上升"] --> B["打开 tokio-console"]
    B --> C{"任务在哪个 .await 卡住了?"}
    
    C -->|channel send 卡住| D["修复:try_send + 超时"]
    C -->|lock 没释放| E["修复:缩小临界区"]
    C -->|无限循环| F["修复:加退出条件"]
    C -->|子任务没 join| G["修复:用 JoinSet"]
    
    D --> H["加上 metrics 监控"]
    E --> H
    F --> H
    G --> H
    
    H --> I["验证:活跃数曲线平稳"]
    I --> J["长期:建立告警阈值"]

五、总结

Tokio 任务泄露是 Rust 异步编程中最容易被忽视但又后果严重的问题。编译器和 borrow checker 帮不上忙,因为没有"借用错误"——代码从所有权角度看完全合规,只是逻辑上永不休眠。

我的经验是:预防优于排查。从一开始就养成三个习惯:

  1. spawn 的任务一定要有明确的退出条件——channel 关闭、超时、或显式的 cancellation token
  2. 用 metrics 持续追踪活跃任务数——哪怕只是打日志,也能看出趋势
  3. 定期跑 tokio-console 看一眼——有时候数值上看不出问题,但可视化会让你瞬间发现异常

作为自学者,经历过一次内存炸掉之后才重视起来的。希望这篇文章能帮你少踩一次这个坑。

如果你也遇到过任务泄露,欢迎在评论区分享你的排查经验,我们下篇见!

XCP实战系列介绍07-使用ASAP2 Editor生成A2l文件详解 介绍通过ASAP2 Editor工具生成A2l文件步骤详解 阅读详情

相关推荐

计算机技术发展5大阶段,现阶段计算机技术应用及发展

【摘要】现代计算机科学技术的发展和普及运用,为世界各国民众基础性生产生活实践活动的组织开展路径造成了深刻影响,本文围绕现阶段计算机技术应用及发展,择取两个具体方面,展开了简要分析。【关键词】计算机技术;应用;发展改革开放以来,计算机设备的广泛运用,促进了计算机科学技术的逐步发展成熟。计算机科学技术是具备新兴表现特征的尖端应用技术,其在现代工业生产和社会生活实践活动过程中的广泛引入运用,给世界各国基...

weixin_42126677的博客 2637

kube-state-metrics暴露k8s中的监控指标

kube-state-metrics 是一个用于从 Kubernetes 集群中生成各种资源对象状态指标的工具。

小太阳DENGJIE的博客 2994

01_MySQL下载、安装与配置(以MySQL8.0.31版本为例)

1.点击下载好的mysql安装包 进入到mysql installer界面。2.选择MySQL Servers选项 一直下拉。

4824

关于grafana的相关知识点

关于grafana的相关知识点

fang0604631023的博客 3777

Windows下用Caddy一键搞定LiveKit本地HTTPS部署(含自签名证书避坑指南)

本文详细介绍了在Windows本地开发环境中,如何利用Caddy服务器一键部署支持HTTPS和WSS的LiveKit实时通信服务。文章重点解决了自签名证书的生成与配置难题,提供了完整的避坑指南和防火墙设置,帮助开发者快速搭建安全的WebRTC测试环境,实现局域网内的实时音视频互动。

weixin_29274969的博客 584

CE 7.4中文版实战:如何用自动汇编功能快速生成游戏修改器(附CT表保存技巧)

本文详细介绍了CE 7.4中文版中自动汇编功能的使用方法,帮助用户快速生成游戏修改器。从环境配置、内存地址定位到自动汇编代码注入,再到CT表保存和独立EXE生成,提供全流程实战指南,适合逆向工程爱好者和游戏修改器开发者。

keras9composer的博客 358

敏感信息泄露总结

一.源代码泄露 二.服务器导致的泄露 Apache类泄露 样例文件泄露 /examples/servlets/servlet/CookieExample /examples/servlets/servlet/RequestHeadersExample /examples/jsp/snp/snoop.jsp /examples/async/async1 cookie泄露 IIS泄露 典型iis短文件名 https://github.com/lijiejie/IIS_shortname_Scanner To

goddemon 1万+

如何免费访问和使用Gemini API?

Gemini Ultra具有最先进的性能,在几个指标上超过了GPT-4的性能。它是第一个在大规模多任务语言理解基准测试中超越人类专家的模型,该基准测试57个不同学科的世界知识和解决问题的能力。Gemini是谷歌迄今为止开发的最先进、最庞大的AI模型。它为多模态而建,理解并处理不同类型的数据,比如文本、代码、音频、图像和视频。下面我们将加载Masood Aslami的图像,并用它来测试Gemini Pro Vision的多模态性。有了Gemini可以为查询提供图像、音频和文本,获得几乎完美的答案。

java_cjkl的博客 1万+

未授权访问漏洞总结

前言:这篇文章主要收集一些常见的未授权访问漏洞。未授权访问漏洞可以理解为需要安全配置或权限认证的地址、授权页面存在缺陷导致其他用户可以直接访问从而引发重要权限可被操作、数据库或网站目录等敏感信息泄露。 0x01 未授权漏洞预览 Active MQ 未授权访问 Atlassian Crowd 未授权访问 CouchDB 未授权访问 Docker 未授权访问 Dubbo 未授权访问 Druid 未授权访问 Elasticsearch 未授权访问 FTP 未授权访问 Hadoop 未授权访问 JBoss 未授权访

LuckySec 6310

智能体在车联网中的应用:一份详尽到每日的100天学习路线图

这100天的旅程,是一次对毅力、学习方法和工程实践能力的综合考验。它不仅关乎掌握一系列技术点,更关乎培养解决复杂系统性问题的思维模式——将宏观的交通需求分解为微观的智能体决策,再通过多智能体协同涌现出宏观的智能行为。当你完成这份大纲时,你将拥有的不仅是一个项目作品集,更是一套应对“智能体+车联网”乃至更广泛AI+垂直领域挑战的方法论。未来已来,期待你成为构建智能交通新生态的关键贡献者。

IT深耕十余载,大道之简 1338

一文读懂 SAP ICF Services:从 SICF 激活到 ABAP OData V2/V4 安全与实战

本文系统化介绍了ABAP系统中ICF服务的关键概念及实践要点。主要内容包括:ICF服务的核心安全机制,需显式激活才能响应HTTP请求;在SICF中正确激活服务的操作步骤;OData V2/V4服务所需的不同ICF节点配置,如V4统一入口节点/sap/opu/odata4;典型问题如default_host未激活会导致HOST_INACTIVE错误;安全实践包括CSRF防护机制和权限对象(S_ICF_ADM)配置;以及实际案例分析和常见ICF服务节点的功能说明。文章为ABAP开发者与运维人员提供了ICF服务管

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 474

Spring boot带来的信息泄露

1、Springboot引起的信息泄露暴露的密码不只我展示的这么多,其他组件碰到后应该多去探索发现。2、拿到密码后能做的也很多。先自我介绍一下,小编13年上师交大毕业,曾经在小公司待过,去过华为OPPO等大厂,18年进入阿里,直到现在。深知大多数初中级java工程师,想要升技能,往往是需要自己摸索成长或是报班学习,但对于培训机构动则近万元的学费,着实压力不小。自己不成体系的自学效率很低又漫长,而且容易碰到天花板技术停止不前。httpshttpshttpshttpshttpshttps。...

Ajekseg的博客 3241

假期搞定!2026国社科申报AI全攻略指南:从选题到创新,7大核心要点手把手教你!

最后给大家推荐的400多所高校教师都在用的AI平台——高级学术版专业应用平台,集成了国际主流学术应用,以及ChatGPT、Claude、Gemini、Grok等Al大模型的高级版本平台,还有,可以辅助大家高效完成科研和学术写作任务,当然撰写硕博论文,课题、职称论文、国社科、国自然基金本子也是手拿把掐。你的任务是:用高度凝练的方式说明在(某一明确国家战略 / 政策方向,如:中国式现代化、共同富裕、基层治理现代化、数字中国、文化强国、国家安全等)背景下,我究竟要研究一个什么“具体而可操作的问题”。

智能AI让学术科研更容易 626

Spring Boot框架敏感信息泄露的完整介绍与SRC实战(附专属字典与PoC)

转载于:https://www.freebuf.com/vuls/289710.html #前言##Spring Boot框架介绍Spring框架功能很强大,但是就算是一个很简单的项目,我们也要配置很多东西。因此就有了Spring Boot框架,它的作用很简单,就是帮我们自动配置,其设计目的是用来简化新Spring应用的初始搭建以及开发过程。Spring Boot框架的核心就是自动配置,只要存在相应的jar包,Spring就帮我们自动配置。该框架使用了特定的方式来进行配置,从而使开发人员不再需要定义样板化的

qq_50854662的博客 8916

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

零基础从零到一暴露 /metrics 端点(内网访问)的庖丁解牛

所有 PHP 服务暴露/metrics端点Nginx 强制内网访问用 Prometheus 实现秒级监控因为最好的系统稳定性,不是祈祷不崩,而是让每一比特都可被观测。

长风破浪会有时的博客 302

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

可造成敏感信息泄露!Spring Boot之Actuator信息泄露漏洞三种利用方式总结

如果没有正确使用Actuator,可能造成信息泄露等严重的安全隐患。其中heapdump作为Actuator组件最为危险的Web端点,因未授权访问被恶意人员获取后进行分析,可进一步获取敏感信息。

WangsuSecurity的博客 1万+

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

Metrics 未授权访问漏洞【原理扫描】

而且该接口未做鉴权控制,从而被安全扫描工具识别为“未授权访问”漏洞。的输出或 HTTP 响应头),我可以进一步帮你确认是哪种服务。可能由某个应用随机使用,也可能是用户或某软件自定义配置的。,它通常不是系统保留或标准服务端口。Metrics 未授权访问漏洞【原理扫描】结合经验和漏洞分析,可以推测这个端口。如果你能提供该端口返回的部分内容(如。并不是某个广泛知名服务的。

喝醉酒的小白 8135

2024年敏感信息泄露总结_rabbitmq漏洞(2),最新大厂网络安全校招面试经验汇总

概念:是一个由Apache基金会所开发的分布式系统基础架构,由于服务器直接在开放了 Hadoop 机器 HDFS 的 50070 web 端口及部分默认服务端口,黑客可以通过命令行操作多个目录下的数据,如进行删除,下载,目录浏览甚至命令执行等操作,产生极大的危害。概念:是一个开源软件项目,是基于Java开发的一种持续集成工具,用于监控持续重复的工作,旨在提供一个开放易用的软件平台,使软件的持续集成变成可能。可以说是最科学最系统的学习路线,大家跟着这个大的方向学习准没问题。默认端口是5601。

2401_84264692的博客 1999

使用Metrics监控应用程序的性能

在编写应用程序的时候,通常会记录日志以便事后分析,在很多情况下是产生了问题之后,再去查看日志,是一种事后的静态分析。在很多时候,我们可能需要了解整个系统在当前,或者某一时刻运行的情况,比如当前系统中对外提供了多少次服务,这些服务的响应时间是多少,随时间变化的情况是什么样的,系统出错的频率是多少。这些动态的准实时信息对于监控整个系统的运行健康状况来说很重要。 一些应用程序,比如对外提供接口或者服务...

weixin_34033624的博客 560

性能指标之资源指标-内存-内存是否泄漏

在稳定性测试(也叫持久测试或疲劳测试)中,需要观察内存是否有泄露。然而使用内存的进程千千万,整个服务器的内存增长似乎也不能判断某个进程的内存有泄露。因此在稳定性测试过程中往往需要全程关注指定进程的内存消耗,比如运行3天、7天。 查看内存使用情况的命令有ps、sar、svmon、vmstat等等,但本文并不从工具使用的角度来介绍,而是从性能测试中关注指标的角度来介绍。如果采用其他命

lin的专栏 1913

Spring Boot信息泄露

参考文章: https://blog.youkuaiyun.com/weixin_45039616/article/details/106637978 https://www.freebuf.com/news/193509.html

谢公子的博客 1万+

组网第63课:安全域划分——Trust/Untrust/DMZ、区域模型、与 VLAN 的关系

一组接口 + 一组策略 + 一条默认拒绝。一组接口:这个域包含哪些物理口、VLAN、子接口;一组策略:这个域到别的域放行什么、拒绝什么;一条默认拒绝:没写进策略的,一律不通。第三条最关键。没有默认拒绝,前面划的域全是装饰。

qq_36765170的博客 569

rust: Fan-out/Fan-in Pattern

本项目基于Rust实现珠宝行业全流程的扇出/扇入模式,采用DDD六层架构。通过ProcessRequestDto与ProcessResponseDto传输数据,将采购、设计、生产等12个业务阶段抽象为可并行执行的FanoutTask子任务。核心由JewelryFanoutFanin实现并行调度:先扇出至12个线程并发执行,再统一扇入汇总结果。系统集成日志(文件+控制台)、重试熔断、内存仓储及依赖注入容器,支持顺序与并发两种调度方式,确保高并发下任务可靠执行与可观测性。

Geovin Du Dream Park 159

Rust组织管理(AI回答)

你想做的事JS / Python 做法Rust 做法把一个文件纳入工程新建文件即可新建 xxx.rs 后,必须在入口写mod xxx;挂载对外暴露函数/结构体export(Python 默认全公开)默认全私有,必须显式加pub引入别处的函数use crate::模块名::函数名;找路径的基准词./ 或 ../(从 src 根出发)、(上一级 ../)、(当前级 ./)日常写项目:不要用 #[path],直接遵守默认规则——

yaoct的博客 153

自建 RustDesk 服务端后,做一个“装完就能连“的客户端

目前市面上的远程工具(如向日葵、toDesk等)免费版基本上都卡的不行,而且收费版好像也会卡。如果有云服务的话,可以基于 RustDesk 的 hbbs / hbbr 自己部署一套,不过会碰到一个问题:每台电脑装完客户端,都得手动去设置里填三样东西——ID 服务器、中继服务器、Key。填错一个就连不上,还得远程指导同事操作。这篇记录两种解决办法,以及云端编译的完整流程。内容基于 RustDesk 1.5.3 的源码。

风声的专栏 605

Rust LeetCode443 算法题解

LeetCode 443 字符串压缩:原地行程编码,用 start 标记组起点、next 扫描组边界、i 原地写出;长度 1 不写计数使编码不膨胀,写指针不越过读指针。时间 O(n),额外空间 O(1)。

weixin_43379230的博客 105
上一篇: Rust 学习曲线可视化:把学习路径画成登山图,标注每个阶段的关键里程碑
下一篇: Rust 错误恢复模式:什么时候重试,什么时候快速失败,什么时候降级
第一程序员
博客等级 码龄1年 1万+粉丝 1822原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值