Rust Concurrency Primitives Flashcards

Arc

原子引用计数，用于在线程间安全地共享数据。

let shared = Arc::new(value);

中级智能指针

ArcSwap

原子性引用交换容器，用于高效共享和更新不可变数据。

let config = ArcSwap::new(Arc::new(data));

高级同步原语

async-channel

异步、无界的多生产者多消费者通道，用于异步任务间的消息传递。

let (tx, rx) = unbounded();
tx.send(42).await?;
let value = rx.recv().await?;

中级异步通信

async-oneshot

异步一次性通道，用于在异步任务之间进行一次性的消息传递。

let (tx, rx) = oneshot::channel::<String>();
tx.send("Hello".to_string()).unwrap();
let message = rx.await.unwrap();

中级异步通信

Async/Await

语言级异步编程支持，简化异步代码的编写和理解。

async fn fetch_data() -> Result { ... }

async fn process() {
    let data = fetch_data().await?;
    // 处理数据
}

中级异步编程

async-fs

提供异步文件系统操作的 Rust 库，支持非阻塞的文件 I/O 操作。

let contents = async_fs::read_to_string("file.txt").await?;

中级异步I/O

async-std

标准库的异步版本，提供与标准库兼容的异步API。

#[async_std::main]
async fn main() {
    let file = File::open("file.txt").await?;
    let content = read_to_string(file).await?;
}

中级异步运行时

Embassy-sync

为嵌入式系统设计的异步并发原语库，提供无分配和中断安全的同步工具。

let channel = Channel::new();
channel.send(data).await;
let received = channel.recv().await;

高级嵌入式

Atomic-Take

轻量级库，提供原子操作的"取出"功能，适用于并发环境中的安全数据交换。

let shared = Arc::new(AtomicTake::new(Some("Hello")));
match shared.take() {
    Some(value) => println!("Took the value: {}", value),
    None => println!("Value already taken"),
}

中级并发原语

Tokio

高性能异步运行时，提供异步任务调度、IO操作和并发原语。

#[tokio::main]
async fn main() {
    let handle = tokio::spawn(async {
        // 异步任务
    });
    handle.await.unwrap();
}

中级异步运行时

smol

小巧而强大的异步运行时，专注于简单性和可组合性。

smol::block_on(async {
    let task = smol::spawn(async {
        // 异步任务
    });
    task.await;
})

中级异步运行时

Manual Future

手动实现Future trait，用于自定义异步操作的底层控制。

impl Future for MyFuture {
    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll {
        // 自定义轮询逻辑
    }
}

高级异步编程

Atomig

高性能原子操作库，提供比标准库更快、更灵活的原子类型和操作。

let atomic = Atomic::::new(0);
atomic.fetch_add(1, Ordering::Relaxed);

高级原子操作

Portable-Atomic

跨平台原子操作库，提供可移植的原子类型和操作。

let atomic = AtomicU8::new(0);
atomic.fetch_add(1, Ordering::SeqCst);

中级原子操作

Atomic Types

原子类型提供无锁的线程安全操作。

let counter = AtomicU64::new(0);

中级原子操作

Watch

用于监视和通知共享状态变化的并发原语。

let (sender, receiver) = watch::channel(0);
sender.send(1).unwrap();
assert_eq!(*receiver.borrow(), 1);

中级并发原语

Barrier

同步屏障，确保多个线程在同一点同步后再继续执行。

let barrier = Barrier::new(3);

中级同步原语

Box

堆内存分配的智能指针，用于存储固定大小或递归数据结构。

let boxed = Box::new(42);

基础智能指针

Chute

高性能、无锁的多生产者单消费者通道实现。

let (tx, rx) = bounded(100);
tx.send(42).unwrap();
let value = rx.recv().unwrap();

中级通信原语

Broadcast Channel

广播通道，允许一个发送者向多个接收者发送相同的消息。

let (tx, _) = broadcast::channel(16);

中级通信原语

FMutex

公平互斥锁实现，确保线程按请求顺序获得锁，防止饥饿。

let mutex = FairMutex::new(data);
let guard = mutex.lock();

中级同步原语

Critical-Section

轻量级库，用于创建和管理临界区，支持单线程和多线程环境。

cs::with(|cs| {
    let data = GLOBAL_DATA.borrow(cs);
    data.set(data.get() + 1);
});

中级同步原语

Crossbeam-Channel

多生产者、多消费者的并发通信通道，用于线程间安全地传递消息。

let (s, r) = unbounded();
s.send(10).unwrap();
assert_eq!(r.recv(), Ok(10));

中级并发通信

Crossbeam-Deque

高效的无锁工作窃取双端队列，用于任务分配和并行计算。

let worker = Worker::new_fifo();
let stealer = worker.stealer();

高级并发集合

Crossbeam-Skiplist

高性能、并发安全的跳表实现，提供有序集合和映射功能。

let map = SkipMap::new();
map.insert(1, "value");
for entry in map.range(0..10) {
    println!("{}: {}", entry.key(), entry.value());
}

高级并发集合

Concurrent Queue

高效的无锁并发队列实现，支持多生产者多消费者模式。

let queue = ConcurrentQueue::bounded(100);
queue.push(value).unwrap();
let item = queue.pop().unwrap();

高级并发集合

DashMap

高性能的并发哈希表实现，支持多线程安全的读写操作。

let map = DashMap::new();
map.insert("key", "value");
if let Some(value) = map.get("key") {
    println!("Value: {}", value);
}

中级并发集合

Cell

单线程内部可变性容器，用于在不可变引用中修改值。

let cell = Cell::new(42);

基础内部可变性

CPU Affinity

允许将线程绑定到特定的 CPU 核心上执行，以优化性能和资源利用。

let core_ids = affinity::get_core_ids().unwrap();
affinity::set_thread_affinity(&[core_ids[0]]).unwrap();
println!("Thread bound to core {:?}", core_ids[0]);

高级性能优化

AtomicWaker

用于异步任务通知的原子化唤醒器，提供线程安全的 Waker 存储和交换。

let waker = AtomicWaker::new();
waker.register(cx.waker());
// 在其他线程中
waker.wake();

高级异步编程

Sharded-Slab

高性能分片槽数据结构，用于快速分配和回收固定大小的对象。

let pool = Pool::new();
let key = pool.create().unwrap();
pool.get_mut(key).unwrap().replace("Hello");

高级并发集合

Condition Variables

用于线程等待特定条件成立。

let cvar = Condvar::new();

高级同步原语

Cow

写时复制智能指针，延迟数据克隆直到需要修改时。

let cow = Cow::from("hello");

中级智能指针

Ctx Thread

提供携带上下文信息的线程创建和管理机制，支持共享状态。

let thread = CtxThread::new(context, |ctx| {
    while ctx.is_running() {
        process_task(&ctx.config);
    }
});

中级线程管理

Singleflight

合并并发请求，防止重复操作，优化系统性能。

let sf = AsyncSingleflight::new();
let result = sf.work("key", async {
    expensive_operation().await
}).await;

中级并发控制

Papaya

专为读密集型工作负载设计的高性能并发哈希表，使用分片技术减少锁竞争。

let map = Map::new();
map.insert("key", 42);
assert_eq!(map.get("key"), Some(&42));

高级并发集合

DashMap

高性能并发哈希映射，使用分片技术减少锁竞争。

let map = DashMap::new();
map.insert("key", "value");

高级并发集合

Left-Right

无锁并发读写数据结构，提供高性能的读操作和线程安全的写操作。

let lr = LeftRight::new(0);
lr.write(|v| *v += 1);
assert_eq!(lr.read(|v| *v), 1);

高级并发数据结构

Bus

高效的发布-订阅消息总线，支持多生产者多消费者模式。

let mut bus = Bus::new(10);
let mut reader = bus.add_rx();
bus.broadcast(message);

中级消息总线

Once Map

线程安全的懒初始化键值存储结构，确保每个键只被初始化一次。

let map = OnceMap::new();
let value = map.get_or_insert(key, || compute_value());

中级并发集合

ScopeGuard

提供类似 Go 语言 defer 的作用域清理机制，确保资源在作用域结束时被正确释放。

let _guard = guard(resource, |r| {
    println!("清理资源: {}", r);
});

中级资源管理

EvMap

无锁并发映射，使用读写分离的设计提供高性能读取。

let (r, w) = evmap::new();
w.insert(key, value);
w.refresh();

高级并发集合

Event Listener

高效的、多生产者-多消费者的通知机制。

let event = Arc::new(Event::new());
let listener = event.listen();
event.notify(3); // 通知3个监听器

中级同步原语

Triggered

一次性事件通知机制，用于跨线程或异步任务的触发控制。

let (trigger, listener) = Trigger::new();
listener.wait(); // 阻塞等待触发
trigger.trigger(); // 触发事件

中级同步原语

Event Listener Strategy

用于构建高效事件监听器的策略库。

let strategy = Strategy::new()
    .spin_for(Duration::from_micros(10))
    .yield_now()
    .sleep(Duration::from_millis(1));
listener.wait_with(strategy);

高级并发优化

fslock

提供文件系统级别锁定机制的 Rust 库，用于跨进程同步。

let mut lock = LockFile::open(Path::new("/tmp/my_lock_file"))?;
if lock.try_lock()? {
    // 执行需要同步的操作
}

中级跨进程同步

Kanal

高性能、零成本的异步通道实现，专为Rust的异步编程设计。

let (tx, rx) = bounded::(10);
tx.send(42).await.unwrap();

中级异步通信

Flume

快速、灵活的多生产者、多消费者通道库，用于线程间通信。

let (tx, rx) = flume::unbounded();
tx.send(42).unwrap();
assert_eq!(rx.recv().unwrap(), 42);

中级通信原语

Future

表示异步计算的特殊类型，可以在未来某个时刻完成并产生值。

async fn get_data() -> Result { ... }
let future = get_data();  // 不会立即执行
executor.spawn(future);   // 交给执行器运行

中级异步编程

Governor

用于实现速率限制的 Rust 库，可以控制并发操作的频率。

let limiter = RateLimiter::direct(Quota::per_second(nonzero!(5u32)));

高级并发控制

Leaky Bucket

漏桶算法实现，用于限制和平滑处理请求的速率。

let bucket = LeakyBucket::builder()
    .max(10)
    .refill_amount(5)
    .refill_interval(Duration::from_secs(1))
    .build();

中级速率限制

API Rate Limiter

灵活的 API 速率限制库，支持多种限流算法和配置选项。

let limiter = RateLimiter::new(
    RateLimiterConfig::new()
        .limit(100)
        .period(Duration::from_secs(60))
        .build()
);

中级速率限制

Go Spawn

提供类似 Go 语言 goroutine 的轻量级线程创建方式。

let handle = go!(|| {
    println!("Hello from go_spawn!");
});

中级线程创建

LazyCell

延迟初始化的单元格，只在首次访问时计算其值。

let lazy: LazyCell = LazyCell::new(|| expensive_computation());

高级延迟初始化

LazyLock

线程安全的惰性初始化，首次访问时才执行初始化函数。

static INSTANCE: LazyLock = LazyLock::new(|| String::from("Hello"));

高级全局变量

LockFree

无锁并发数据结构，提供高性能的线程安全操作。

let queue = Arc::new(Queue::new());
queue.push(42);
assert_eq!(queue.pop(), Some(42));

高级并发数据结构

lockfree-object-pool

无锁对象池，用于高效地管理和重用对象，避免频繁的内存分配和释放。

let pool = ObjectPool::new(10, || MyObject(0));
let obj = pool.try_pull().expect("Pool is empty");
// 使用对象
pool.push(obj);

高级内存管理

Loom

用于测试并发 Rust 代码的工具，可以帮助发现难以重现的并发 bug。

loom::model(|| {
    // 并发代码测试
});

高级并发测试

MPSC Channel

多生产者单消费者通道，用于线程间安全地传递消息。

let (tx, rx) = mpsc::channel();

基础通信原语

Async-Lock

异步互斥锁，专为异步代码设计的非阻塞锁实现。

let lock = Lock::new(0);
let value = lock.lock().await;

高级异步同步

Async-Mutex

异步互斥锁，用于在异步上下文中保护共享资源。

let mutex = Arc::new(Mutex::new(0));
let mut guard = mutex.lock().await;
*guard += 1;

中级异步同步原语

async-lock

异步互斥锁，用于在异步环境中安全地共享和修改数据。

let lock = Lock::new(0);
let guard = lock.lock().await;

中级异步同步

Mutex

互斥锁是最基础的并发原语之一，用于保护共享数据。

let mutex = Mutex::new(0);

基础同步原语

Once

确保某段代码只执行一次的同步原语。

static INIT: Once = Once::new();

中级同步原语

OnceCell

一次性初始化的单元格，可以在运行时设置一次值。

let cell = OnceCell::new();
cell.set("value").unwrap();

中级一次性初始化

OnceLock

用于一次性初始化全局变量，线程安全且零开销。

static INSTANCE: OnceLock = OnceLock::new();

高级全局变量

Parking

提供高效的线程阻塞和唤醒机制，是实现各种同步原语的基础工具。

let parker = Parker::new();
let unparker = parker.unparker().clone();
// 在另一个线程中：
unparker.unpark();
// 在当前线程：
parker.park();

高级同步原语

Oneshot Channel

一次性使用的异步通信通道，用于在两个任务之间传递单个值。

let (tx, rx) = oneshot::channel();
tx.send("hello").unwrap();
let received = rx.await.unwrap();

中级异步通信

Async-Oneshot Channel

无需运行时的异步一次性通道，专为无运行时环境下的异步通信设计。

let (sender, receiver) = oneshot();
sender.send(value).ok();
let result = receiver.await?;

高级异步通信

Async Singleflight

异步单飞模式，用于合并并发的重复请求，减少资源消耗和提高性能。

let sf = AsyncSingleflight::new();
let result = sf.work("key", async {
    // 异步操作
}).await;

高级并发控制

Async Priority Channel

异步优先级通道，用于在异步环境中进行优先级消息传递。

let (sender, receiver) = PriorityChannel::new();
sender.send(2, "中等优先级").await.unwrap();
let (priority, msg) = receiver.recv().await.unwrap();

高级异步通信

Parking_lot

更紧凑、更高效的同步原语库，提供了标准库同步原语的替代实现。

let mutex = parking_lot::Mutex::new(0);
let guard = mutex.lock();

高级同步原语

Process Control

提供一套用于管理和控制进程的工具，支持进程生命周期管理和资源监控。

let mut process = Process::new("example_child")?;
process.start()?;
process.set_priority(Priority::High)?;

中级进程管理

Process Command

进程控制原语，用于创建、配置和管理子进程。

let output = Command::new("echo")
    .arg("Hello")
    .output()?;

中级系统编程

Rc

单线程引用计数智能指针，用于实现多重所有权。

let shared = Rc::new(value);

基础智能指针

RefCell

单线程内部可变性容器，提供运行时借用检查的可变引用。

let data = RefCell::new(vec![1, 2, 3]);

中级内部可变性

RwLock

读写锁允许多个读操作同时进行，但写操作需要独占访问。

let lock = RwLock::new(data);

中级同步原语

Shuttle

用于测试并发 Rust 代码的库，通过模拟不同的执行顺序来发现潜在的并发问题。

shuttle::check_random(|| {
    // 你的并发代码
});

高级并发测试

Semaphore

计数信号量，用于控制对资源的并发访问数量。

let semaphore = Semaphore::new(3);

中级同步原语

Terminate Thread

安全地终止正在运行的线程，提供优雅的线程停止机制。

let handle = spawn(|terminator| {
    while !terminator.is_terminated() {
        // work
    }
});

中级线程控制

SendWrapper

将非 Send 类型包装成 Send 类型，使其可以安全地在线程间传递。

let wrapped = SendWrapper::new(non_send_data);

高级线程安全

SCC

可扩展的并发容器库，提供高性能的并发数据结构。

let map = scc::HashMap::default();
map.insert("key", "value");

高级并发集合

SCC2

高性能的可扩展并发容器库，提供无锁数据结构。

let map = scc2::HashMap::default();
map.insert(key, value);

高级无锁算法

Thread

Rust中的线程是实现并发执行的基本单位，可以同时运行多个独立的代码路径。

let handle = thread::spawn(|| {
    println!("Hello from a thread!");
});

基础并发原语

Thread Scope

作用域线程，允许在特定作用域内安全地使用栈上数据创建线程。

thread::scope(|scope| {
    scope.spawn(|| {
        println!("Scoped thread");
    });
});

中级并发原语

Crossbeam-utils

提供一系列用于并发编程的实用工具，包括原子单元格、回退算法和缓存行填充。

let atomic = AtomicCell::new(0);
atomic.fetch_add(1);

中级并发工具

Crossbeam Scope

提供安全的方式创建作用域线程，允许访问非 'static 生命周期的数据。

crossbeam::scope(|s| {
    s.spawn(|_| {
        println!("Crossbeam scoped thread");
    });
}).unwrap();

中级并发原语

Rayon Scope

提供安全高效的并行任务执行方式，允许访问栈上数据。

rayon::scope(|s| {
    s.spawn(|_| { /* 并行任务 */ });
});

中级并行计算

Thread Control

提供灵活的线程控制机制，允许暂停、恢复和终止线程执行。

let (flag, control) = make_pair();
// 在另一个线程中
while flag.alive() {
    // 工作代码
    flag.wait(); // 检查暂停
}

中级线程管理

Thread Priority

线程优先级是操作系统调度线程的重要参数，可以影响线程获取CPU时间片的机会。

let handle = thread::spawn(|| {
    assert!(set_current_thread_priority(ThreadPriority::Max).is_ok());
    println!("Hello from a high priority thread!");
});

中级线程管理

Thread Park/Unpark

线程的 park 和 unpark 机制允许线程暂停执行并等待被唤醒，提供了一种低级别的线程协调方式。

let parker_thread = thread::current();
thread::spawn(move || {
    // 做一些工作...
    parker_thread.unpark();
});
thread::park();

中级线程控制

Rusty_pool

高性能、可定制的线程池库，提供灵活的并发任务执行。

let pool = ThreadPool::new(2, 4);
pool.execute(|| {
    println!("Task running");
});

中级并发执行

ThreadPool

线程池用于管理一组工作线程，高效处理并发任务。

let pool = ThreadPool::new(4);
pool.execute(|| { println!("Task executed"); });

中级并发执行

线程安全的 HashMap

线程安全的哈希映射，使用互斥锁保护内部数据。

let map = Arc::new(Mutex::new(HashMap::new()));
map.lock().unwrap().insert("key", "value");

中级并发集合

线程安全的 Vec

线程安全的动态数组，允许多线程安全访问和修改。

let vector = Arc::new(Mutex::new(Vec::new()));
vector.lock().unwrap().push(42);

中级并发集合

AwaitGroup

异步等待组，用于等待一组异步任务完成，是 WaitGroup 的异步版本。

let wg = WaitGroup::new();
wg.add(1);
// 在异步任务中
wg.done();
wg.wait().await;

中级异步同步

WaitGroup

用于等待一组任务完成的同步原语。

let wg = WaitGroup::new();
wg.add(1);
// ... 在其他线程中调用 wg.done()
wg.wait();

中级同步原语

wg

轻量级的 WaitGroup 实现，用于等待多个并发任务完成。

let wg = WaitGroup::new();
thread::spawn({
    let wg = wg.clone();
    move || {
        // 任务完成
        wg.done();
    }
});
wg.wait();

中级同步原语

waker-fn

提供了一种简单的方法来创建自定义的 Waker，用于异步任务的唤醒机制。

let waker = waker_fn(|| {
    println!("Task is ready!");
});

高级异步编程

Rust 并发原语学习卡

分类导航

99个并发原语，点击卡片了解更多

Arc

ArcSwap

async-channel

async-oneshot

Async/Await

async-fs

async-std

Embassy-sync

Atomic-Take

Tokio

smol

Manual Future

Atomig

Portable-Atomic

Atomic Types

Watch

Barrier

Box

Chute

Broadcast Channel

FMutex

Critical-Section

Crossbeam-Channel

Crossbeam-Deque

Crossbeam-Skiplist

Concurrent Queue

DashMap

Cell

CPU Affinity

AtomicWaker

Sharded-Slab

Condition Variables

Cow

Ctx Thread

Singleflight

Papaya

DashMap

Left-Right

Bus

Once Map

ScopeGuard

EvMap

Event Listener

Triggered

Event Listener Strategy

fslock

Kanal

Flume

Future

Governor

Leaky Bucket

API Rate Limiter

Go Spawn

LazyCell

LazyLock

LockFree

lockfree-object-pool

Loom

MPSC Channel

Async-Lock

Async-Mutex

async-lock

Mutex

Once

OnceCell

OnceLock

Parking

Oneshot Channel

Async-Oneshot Channel

Async Singleflight

Async Priority Channel

Parking_lot

Process Control

Process Command

Rc

RefCell

RwLock