Rust 并发安全相关的几个概念(下)

Rust中的Send和Sync 关于Sync和Send的含义 sync 想要一个类型的同一个变量可以在不同线程同时拥有它的不可变引用,则必须实现Sync send 想要一个类型可以在线程之间移动,则必须实现Send 为什么要有Send和Sync 理论上,不同线程拥有同一个变量的不可变引用(共享读)是安全的,讲一个对象move给另一个线程也是安全的(只有一个线程拥有它)。 问题出在内部可变性上,下面通过RefCell和Sync来说明 Sync 内部可变性如RefCell,在内部维护一个不可变借用的引用计数. 这意味着&RefC 阅读详情

引言

本文介绍 Rust 并发安全相关的几个概念:Send、Sync、Arc,Mutex、RwLock 等之间的联系。这是其中的下篇,主要介绍 Arc,Mutex、RwLock 这几个线程安全相关的类型。

在上一节1中,讲解了 Send 和 Sync 这两个线程安全相关的 trait,在此基础上展开其它相关类型的讲解。

Rc

Rc 是 Reference Counted(引用计数)的简写,在 Rust 中,这个数据结构用于实现单线程安全的对指针的引用计数。之所以这个数据结构只是单线程安全,是因为在定义中显式声明了并不实现 Send 和 Sync 这两个 trait:

#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized> !marker::Send for Rc<T> {}

#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized> !marker::Sync for Rc<T> {}

个中原因,是因为 Rc 内部的实现中,使用了非原子的引用计数(non-atomic reference counting),因此就不能满足线程安全的条件了。如果要在多线程中使用引用计数,就要使用 Arc 这个类型:

Arc

与 Rc 不同的是,Arc 内部使用了原子操作来实现其引用计数,因此 Arc 是Atomically Reference Counted(原子引用计数)的简写,能被使用在多线程环境中,缺陷是原子操作的性能消耗会更大一些。虽然 Arc 能被用在多线程环境中,并不意味着 Arc 天然就实现了 Send 和 Sync,来看看这两部分的声明:

#[stable(feature = "rust1", since = "1.0.0")]
unsafe impl<T: ?Sized + Sync + Send> Send for Arc<T> {}
#[stable(feature = "rust1", since = "1.0.0")]
unsafe impl<T: ?Sized + Sync + Send> Sync for Arc<T> {}

从声明可以看出:一个 Arc 类型,当且仅当包裹(wrap)的类型 T 满足 Sync 和 Send 时才能被认为是满足 Send 和 Sync 的类型。来做一个实验:

#![feature(negative_impls)]
use std::sync::Arc;

#[derive(Debug)]
struct Foo {}
impl !Send for Foo {}

fn main() {
    let foo = Arc::new(Foo {});
    std::thread::spawn(move || {
        dbg!(foo);
    });
}

在以上的代码中,由于在第 8 行显示声明了 Foo 这个类型不满足 Sync,所以这段代码编译不过,报错信息如下:

    = help: the trait `Sync` is not implemented for `Foo`
    = note: required because of the requirements on the impl of `Send` for `Arc<Foo>`

反之,如果把第 8 行去掉,代码就能编译通过了。于是,这就带来一个问题:Arc 虽然能被用在多线程环境中,但并不是所有Arc 都是线程安全的,如果里面包裹的类型 T 并不满足多线程安全,是不是就不能使用了?解开这个问题的答案请使用 Mutex 类型:Mutex

Mutex

与其它语言不同的是,Rust 中类似 Mutex、RwLock 这样的结构都有一个包裹类型,这带来一个好处:使用这些数据类型保护对一个数据的访问时,是能够明确知道保护的哪个数据的。比如在 C 语言中,可能只是看到一个简单的 mutex 定义:

// 仅看到这个定义,并不知道这个 mutex 保护哪个数据
mutex_t mutex;

但是在 Rust中,定义一个 Mutex 是必须知道保护什么类型的哪个数据的:

let foo = Arc::new(Mutex::new(Foo {}));

这无疑给阅读代码带来了便利。回到线程安全这个话题来,Mutex 只要求包裹的类型 T 满足 Send 就可以将它转成满足 Send 和 Sync 的类型 Mutex:

#[stable(feature = "rust1", since = "1.0.0")]
unsafe impl<T: ?Sized + Send> Send for Mutex<T> {}
#[stable(feature = "rust1", since = "1.0.0")]
unsafe impl<T: ?Sized + Send> Sync for Mutex<T> {}

这意味着:即便一个类型只满足了 Send,不能直接用于 Arc 满足多线程安全,但是可以通过包装成 Mutex 来达到线程安全的目的。来看看上面的代码如何使用 Mutex 来进行改造:

#![feature(negative_impls)]
use std::sync::{Arc, Mutex};
#[derive(Debug)]
struct Foo {}
impl !Sync for Foo {}
fn main() {
    let foo = Arc::new(Mutex::new(Foo {}));
    std::thread::spawn(move || println!("{:?}", foo));
}

上面这段代码中,Foo 类型声明不满足 Sync,所以不能直接声明 Arc 用在多线程环境中,这一点上面的实验已经证明。但是,可以在 Foo 外面再包一层 Mutex,变成 Arc<Mutex> 这样就能在多线程中使用了。即:一个只需要满足 Send 要求的类型 T,只要经过 Mutex 的包裹变成类型 Mutex,就变成了一个线程安全的类型。个中原因:Mutex 只要求类型 T 满足 Send 即可,内部的机制会保证这个类型在多线程环境下安全访问。RwLock

RwLock

讲解了 Mutex,来看看 RwLock 的使用,顾名思义:RwLock 提供了读写锁的实现。它的 Send 和 Sync 要求如下:

impl<T: ?Sized + Send> Send for RwLock<T>
impl<T: ?Sized + Send + Sync> Sync for RwLock<T>

对比可以看到:RwLock 要满足 Sync,要求类型 T 同时满足 Send 和Sync,这个条件是比 Mutex 更强的条件。也可以这么来理解 RwLock 和 Mutex 的区别:

  • RwLock:由于要求内部的类型 T 必须满足 Sync,于是在多个线程中通过 RwLock 同时访问 & T 是安全的。
  • Mutex:当 Mutex 对内部的数据进行加锁操作时,相当于将内部的数据发送到了加锁成功的线程上,而解锁时又会将内部数据发送到另一个线程上,于是 Mutex 就仅要求 T 满足 Send 即可。

Because of those bounds, RwLock requires its contents to be Sync, i.e. it's safe for two threads to have a &ptr to that type at the same time. Mutex only requires the data to be Send, because conceptually you can think of it like when you lock the Mutex it sends the data to your thread, and when you unlock it the data gets sent to another thread.

(见:Mutex vs RwLock : rust2)Interior Mutability

Interior Mutability

Mutex 和 RwLock 的作用,除了将类型 T 包裹起来,提供对该类型数据的多线程安全访问之外,还有一个大的用处:Interior mutability。在 Rust 中,如果传入类型方法的 Self 引用不是 mut 类型的话,是无法对该对象的成员就行修改的,比如:

#[derive(Debug)]
struct Foo {
    pub a: u32,
}
fn main() {
    let foo = Foo { a: 0 };
    foo.a = 1;
}

这段代码无法编译通过,因为 foo 类型为 Foo,因此无法修改其成员,编译器提醒说可以通过把变量 foo 变成可变类型来解决:

error[E0594]: cannot assign to `foo.a`, as `foo` is not declared as mutable
 --> src/main.rs:8:5
  |
7 |     let foo = Foo { a: 0 };
  |         --- help: consider changing this to be mutable: `mut foo`
8 |     foo.a = 1;
  |     ^^^^^^^^^ cannot assign

但是,如果将内部的成员 a 使用 Mutex 重新包装,即便 foo 仍然不是 mut 类型,也可以进行修改了:

use std::sync::Mutex;
#[derive(Debug)]
struct Foo {
    pub a: Mutex<u32>,
}
fn main() {
    let foo = Foo { a: Mutex::new(0) };
    let mut a = foo.a.lock().unwrap();
    *a = 1;
}

这个特点,被称为内部可变性(Interior mutability),这是 Rust 中的一个设计模式,它允许你即使在有不可变引用时也可以改变数据。

总结

  • Send 和 Sync 是线程安全类型定义时的两类 marker trait,提供给编译器检查之用。
  • 除非显式声明不满足这两个 trait,否则类型都是默认满足这两个 trait 的。
  • 一个类型要满足这两类 trait,当且仅当该类型内部的所有成员都满足,编译器在编译时会进行检查。
  • Rc 只能提供引用计数功能,并不能在多线程环境下使用;反之,Arc 内部使用原子变量实现了引用计数,因此可以在多线程环境下使用。
  • 一个类型 T 如果只满足 Send,可以通过 Mutex 包裹成 Mutex 类型来满足多线程安全;但是 RwLock 要求比 Mutex 更严格。
  • 除了多线程安全之外,Mutex 和 RwLock 等类型还提供了内部可变性(Interior mutability)这个作用。

参考资料

  • Arc and Mutex in Rust | It's all about the bit3
  • Sync in std::marker - Rust4
  • Send in std::marker - Rust5
  • Send and Sync - The Rustonomicon6
  • rust - Understanding the Send trait - Stack Overflow7
  • Understanding Rust Thread Safety8
  • An unsafe tour of Rust’s Send and Sync | nyanpasu64’s blog9
  • Rust: A unique perspective10
  • std::rc - Rust11
  • Arc in std::sync - Rust12
  • Mutex in std::sync - Rust13
  • RwLock in std::sync - Rust14
  • multithreading - When or why should I use a Mutex over an RwLock? - Stack Overflow15

关于 Databend

Databend 是一款开源、弹性、低成本,基于对象存储也可以做实时分析的新式数仓。期待您的关注,一起探索云原生数仓解决方案,打造新一代开源 Data Cloud。

Footnotes

  1. 周刊(第19期):Rust并发安全相关的几个概念(上) - codedump的网络日志 ↩

  2. https://www.reddit.com/r/rust/comments/5bx34b/mutex_vs_rwlock ↩

  3. Arc and Mutex in Rust | It's all about the bit ↩

  4. Sync in std::marker - Rust ↩

  5. Send in std::marker - Rust ↩

  6. Send and Sync - The Rustonomicon ↩

  7. rust - Understanding the Send trait - Stack Overflow ↩

  8. Understanding Rust Thread Safety ↩

  9. An unsafe tour of Rust’s Send and Sync | nyanpasu64’s blog [OLD] ↩

  10. Rust: A unique perspective ↩

  11. std::rc - Rust ↩

  12. Arc in std::sync - Rust ↩

  13. Mutex in std::sync - Rust ↩

  14. RwLock in std::sync - Rust ↩

  15. multithreading - When or why should I use a Mutex over an RwLock? - Stack Overflow ↩

Rust中的并行与并发优化:释放多核性能 并行与并发是计算机领域中重要的概念,它们都与多核性能的释放息息相关。并行是指同时执行多个任务或操作,通常是通过利用多个处理器核心或线程来实现的。在计算机系统中,多个任务可以并行执行,以提高整体的计算速度和效率。​而并发则是指多个任务或操作在同一时间段内执行,通过时间片轮转或者任务切换的方式,使得用户感觉多个任务是同时执行的。与并行不同的是,并发是在单个处理器核心或线程上进行的,通过快速切换任务的方式实现多个任务的交替执行。​。 阅读详情

相关推荐

Rust:何以内存安全

Rust 通过所有权、借用检查、生命周期和无锁并发等机制,构建了一个强大而灵活的内存安全体系。这些机制在编译时运行,确保了代码的内存安全性,减少了运行时错误和漏洞。虽然 Rust 的学习曲线相对较陡,但其提供的内存安全保障和性能优势,使其成为系统级编程和并发编程领域的理想选择。随着 Rust 社区的不断壮大和生态系统的日益完善,越来越多的项目开始采用 Rust 作为主要编程语言。对于追求高性能和内存安全的开发者来说,掌握 Rust 的内存安全机制,将是一项极具价值的技能。

无聊人的有趣博客 2069

rust send sync 理解

关于Sync和Send的含义 sync 想要一个类型的同一个变量可以在不同线程同时拥有它的不可变引用,则必须实现Sync send 想要一个类型可以在线程之间移动,则必须实现Send send 表示跨线程move,sync表示跨线程share data,两者基本就是ownership和borrow的区别 如果一个类型可以安全地传递给另一个线程,这个类型是 Send 如果一个类型可以安全地被多个线程共享 (也就是 &T 是 Send),这个类型是 Sync Send 和 Sync 是

书山有路勤为径 1515

Rust在并发编程中如何确保线程安全?

Rust通过其独特的所有权系统、生命周期机制、互斥锁、原子操作、消息传递机制以及类型系统和特质系统等一系列特性,为并发编程提供了强大的线程安全保障。此外,使用Rust的并发原语(如异步/等待、Future和Stream等)来构建高效且安全的并发程序也是非常重要的。Rust,一种由Mozilla主导开发的编程语言,以其卓越的内存安全性、零成本抽象和强大的并发编程能力而著称。通过特质系统,Rust提供了强大的抽象能力,使得并发编程更加灵活和可扩展。Rust的类型系统和特质系统也为实现线程安全提供了强大的支持。

Lindaoland的博客 1053

【从零开始学习Rust】Rust中的字符串和常用方法

str和String。它们分别代表着不同的字符串存储方式和特性。&str:字符串切片类型,通常用于引用字符串数据的不可变视图。&str是一个不可变的引用,它指向存储在其他地方的字符串数据。&str通常用于函数参数、字符串切片操作和字符串的读取操作。String:字符串类型,代表一个可变、可增长、UTF-8 编码的字符串。String类型是基于堆内存分配的,可以动态地分配和释放内存,支持各种字符串操作和方法。String类型通常用于需要动态创建、修改和拥有字符串数据的场景。

岁月催人老的博客 599

【Rust多线程】Rust并发编程,如何轻松实现无畏并发

进程是资源分配的最小单位,线程是CPU调度的最小单位。每个进程都最少有一个线程,而这个线程就是我们常说的主线程 安全并高效的处理并发编程是 Rust 的另一个主要目标。 并发编程(Concurrent programming),代表程序的不同部分相互独立的执行,而 并行编程(parallel programming)代表程序不同部分于同时执行, 这两个概念随着计算机越来越多的利用多处理器的优势时显得愈发重要。

景天科技苑 3万+

MTK PE+2.0介绍

  PE+2.0介绍:   1.      PE+2.0的状态机: 2.      升压波形协议及编码规则: PE+2.0软件设计:   在充电器类型为标充且底层电量SOC在1%—95%之间时,开始PE+2.0升压充电器的检测:首先将VBUSreset至5V,之后发送8.5的current pattern再获取此时VBUS电压和8.5V比较,若其与8.5的差值绝对值在0.5之...

raydom07的博客 1万+

【Rust】Rust学习 第十六章无畏并发

例如,Erlang 有着优雅的消息传递并发功能,但只有模糊不清的在线程间共享状态的方法。对于高级语言来说,只实现可能解决方案的子集是一个合理的策略,因为高级语言所许诺的价值来源于牺牲一些控制来换取抽象。然而对于底层语言则期望提供在任何给定的情况下有着最高的性能且对硬件有更少的抽象。因此,相比花费大量时间尝试重现运行时并发 bug 出现的特定情况,Rust 会拒绝编译不正确的代码并提供解释问题的错误信息。并发问题的强有力的工具!如果这是一本专注于并发和/或并行的书,我们肯定会更加精确的。

StudyWinter的博客 1768

ctftools-all-in-one使用说明

OAEP (Optimal Asymmetric Encryption Padding) 是一种用于RSA加密的填充方案,目的是提高RSA加密的安全性。在CTF比赛中,如果模数N的两个因子比较接近,使用"费马分解(N)"可能会更快地得到结果;OAEP 是 RSA 的一种标准填充方式(在 PKCS#1 v2.0+ 中定义),因此这类题目本质上仍是 RSA 题,但。,导致你不能直接用常规的 RSA 解密公式 �=�� mod �m=cdmodN 得到有意义的明文。如果你在 CTF 中遇到 RSA 题,

2501_91682449的博客 1729

rust变量绑定、拷贝、转移、引用、指针

...

nameofcsdn的博客 1969

告别黑盒调试:用MMSegmentation可视化工具链,从训练到评估一目了然

本文介绍了如何利用MMSegmentation的可视化工具链,从训练到评估实现语义分割模型的透明化调试。通过整合日志分析、混淆矩阵、PR曲线等工具,开发者可以快速定位模型问题,优化性能。文章详细展示了训练曲线分析、性能剖析、混淆矩阵解读和PR曲线应用等关键步骤,帮助用户告别黑盒调试,提升模型开发效率。

weixin_29100927的博客 105

水下探测小白必看:单波束vs多波束声呐,5分钟搞懂核心区别

本文为水下探测新手清晰解析了单波束与多波束声呐的核心区别。单波束声呐如同精准的“手电筒”,进行逐点扫描,适用于定点测深和目标探测;而多波束声呐则像“聚光灯”,能一次性覆盖一个扇区,高效获取海底地形三维信息,是海底测绘和水下三维建模的理想选择。文章通过生动的比喻和对比表格,帮助读者快速理解两者原理、效率差异及适用场景。

linux6sysadmin的博客 1050

Rust 并发安全相关的几个概念(上)

本文介绍一下Rust并发安全相关的几个概念Send、Sync、Arc,Mutex、RwLock等之间的联系。这是其中的上篇,主要介绍Send、Sync这两个trait。

Databend的博客 512

Zigbee通信(CC2530终端 + ESP32-C6协调器)

实现了CC2530 zigbee终端与ESP32-C6 zigbee协调器的通信交互。

Ecsply的博客 2572

【Rust并发集合】如何在多线程中并发安全地使用集合

集合类型是我们编程中常用的数据类型,Rust 中提供了一些集合类型,比如`Vec<T>`、`HashMap<K, V>`、`HashSet<T>`、`VecDeque<T>`、`LinkedList<T>`、`BTreeMap<K,V>`、`BTreeSet<T>` 等。 要实现线程安全的 Vec,可以使用 Arc(原子引用计数)和 Mutex(互斥锁)的组合。 Arc 允许多个线程共享拥有相同数据的所有权,而 Mutex 用于在访问数据时进行同步,确保只有一个线程能够修改数据。

景天科技苑 2万+

FPGA调试利器:VIO与ILA在Vivado中的实战应用指南

本文详细介绍了Vivado中FPGA调试工具VIO与ILA的实战应用技巧。VIO作为虚拟输入/输出工具,可实时调整参数;ILA作为集成逻辑分析仪,能高效捕获内部信号。文章通过具体案例展示了如何配置ILA采样深度、触发条件,以及VIO的动态参数调整功能,帮助开发者提升上板调试效率,解决常见通信失败、数据不同步等问题。

weixin_42553471的博客 427

从零开始解析N-CMAPSS数据集:航空发动机健康管理的入门指南

本文详细解析了N-CMAPSS数据集在航空发动机健康管理中的应用,从数据集的构成、关键变量到实际数据分析方法,为初学者提供了全面的入门指南。通过Python代码示例,展示了如何加载、探索和建模这一复杂数据集,帮助读者掌握航空发动机性能预测的核心技术。

weixin_29063979的博客 325

30天拿下Rust之并发

随着多核处理器和分布式系统的普及,并发编程成为了现代软件开发中不可或缺的一部分。然而,并发编程也是一项极具挑战性的任务,因为它涉及到数据共享、线程同步和竞态条件等复杂问题。在这些挑战面前,Rust以其独特的内存安全性和并发原语,为开发者提供了一个安全、高效且优雅的并发编程环境。Rust以其强大的内存安全性和丰富的并发原语,为开发者提供了一个安全、高效且优雅的并发编程环境。通过合理利用Rust的并发特性,开发者可以编写出高性能、高可靠性的并发应用程序,满足现代软件开发的需求。

hope_wisdom的技术博客 2897

RK3568笔记五十四:SORT实时目标追踪

YOLOv5具备目标检测的功能,把视频分解成多幅图像并逐帧执行时,如果视频帧中有多个目标,如何知道一帧中的目标和上一帧是同一个对象就是目标跟踪的工作。DeepSort是实现目标跟踪的算法,从sort(simple online and realtime tracking)演变而来,使用卡尔曼滤波器预测所检测对象的运动轨迹,匈牙利算法将它们与新的检测目标相匹配。结合YOLOv5和DeepSORT可以在实时场景中实现高效的目标检测和跟踪。

792

Rust 如何处理高并发场景?(Rust高并发、Rust并发问题)(Rust Arc、Rust Mutex、Rust RwLock读写锁、Rust Atomic、Rust async/await)

Rust 提供了多种方式来处理高并发场景,包括共享内存的线程安全类型、无锁编程模型、以及适用于 I/O 密集型任务的异步编程模型。对于I/O 密集型任务,异步编程是理想选择;对于CPU 密集型任务,线程池和无锁编程可能会提供更好的性能;而对于共享数据访问的场景,Arc或 RwLock等类型是常用的解决方案。通过合理选择并发工具,Rust 提供了强大的并发能力和内存安全保障,能够应对多种高并发需求。。

Dontla的博客 1849

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

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

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

rust 并发

go 语言面试中,经常会被问到 go 语言的优势,go 的高并发能力便是优势之一。那么,rust 的并发如何呢?我们先从如何使用并发谈起,接下来会列举几个例子来说明 rust 并发编程。

小知识折射大智慧 5141

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

编程之道:Rust 的安全与并发

1.背景介绍 Rust 是一种新兴的编程语言,它在安全性和并发性方面具有显著优势。Rust 的设计目标是为那些需要高性能和安全的系统编程任务而设计的。在传统的系统编程语言中,如 C 和 C++,安全性和并发性是很难实现的。Rust 通过引入一些独特的特性和抽象,使得编写安全和并发的代码变得更加容易。 在本文中,我们将深入探讨 Rust 的安全性和并发性特性,以及如何使用这些特性来编写更安全和高...

AI天才研究院 923

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

Rust并发编程安全实践:从理论到实战

Rust的并发编程是一个非常强大和安全的特性,它通过所有权系统、借用规则和各种同步原语来确保并发安全。通过本文的介绍,希望能帮助大家了解如何使用Rust的并发编程,也希望大家能在实际开发中应用这些最佳实践。保持学习,保持输出!今天终于搞懂了并发编程,哭死!向大佬们低头学习!

no1coder的博客 1万+

Rust并发编程实践:10分钟入门系统级编程

Rust并发编程实践:10分钟入门系统级编程

异构算力老群群(在读985计算机博士生)的技术博客 3407

告别并发陷阱:rust-clippy教你写出安全无死锁的Rust代码

在Rust编程中,并发安全一直是开发者面临的重要挑战。rust-clippy作为Rust官方推荐的代码检查工具,提供了强大的并发陷阱检测能力,帮助开发者在编译阶段就能发现潜在的死锁风险和线程安全问题。本文将介绍rust-clippy如何通过静态分析技术,识别常见的并发错误模式,并提供实用的代码改进建议。 ## 🚨 常见的并发陷阱与rust-clippy的解决方案 ### 1. 重复锁定导致的

gitblog_00814的博客 1032

rust并发

rust默认仅支持一对一线程,也就是说操作系统线程。可以引入crate包来使用绿色线程。只支持多个生产者和一个消费者。

喜欢打篮球的普通人 889

Rust线程构建安全并发应用

Rust中的线程提供了一种在应用程序中实现并发执行的强大方法。然而,确保线程安全对于避免数据竞争和维护正确的程序行为至关重要。通过理解线程安全概念,使用Mutex等同步原语,并利用无锁场景的原子类型,你可以在Rust中安全高效地构建并发应用程序。确保安全并发性的另一种流行的方法是消息传递,其中线程或参与者通过相互发送包含数据的消息进行通信。Go语言哲学:“不要通过共享内存进行通信,采用消息通信代替共享内存。” Rust的标准库也提供了Channel的实现,它支持数据通过通道从一个线程发送到另一个线程。

neweastsun的专栏 759
上一篇: Databend 性能剖析方法与工具
下一篇: 如何设置 Databend 开发环境
Databend
博客等级 码龄5年 1458粉丝 363原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值