crossbeam-rs/crossbeam

★ 8,438RustAudience · developerComplexity · 4/5LicenseSetup · moderate

Mindmap

mindmap
  root((crossbeam))
    Concurrent Tools
      Thread channels
      Work-stealing queues
      Atomic types
    Synchronization
      Reader-writer lock
      WaitGroup utility
      Thread scoping
    Memory Tools
      Epoch garbage collection
      Cache-line padding
    Design
      Standalone sub-crates
      Requires Rust 1.74

mindmap root((crossbeam)) Concurrent Tools Thread channels Work-stealing queues Atomic types Synchronization Reader-writer lock WaitGroup utility Thread scoping Memory Tools Epoch garbage collection Cache-line padding Design Standalone sub-crates Requires Rust 1.74

Click or tap to explore — scroll the page freely

Things people build with this

USE CASE 1

Send messages between threads in a Rust program using Crossbeam's channels instead of the standard library's.

USE CASE 2

Build a parallel task scheduler where idle threads steal work from busy ones using the work-stealing deque.

USE CASE 3

Share memory safely between threads without corruption using Crossbeam's atomic types and epoch-based garbage collection.

USE CASE 4

Replace a standard Mutex with Crossbeam's reader-writer lock in a read-heavy concurrent Rust service.

Tech stack

Rust

Getting it running

Difficulty · moderate Time to first run · 30min

Requires comfort with Rust's ownership model, advanced features like epoch GC assume familiarity with lock-free programming concepts.

Use freely for any purpose, including commercial use, under your choice of MIT or Apache 2.0 license.

In plain English

Crossbeam is a library for the Rust programming language that gives developers tools for writing programs that do multiple things at the same time. When a program runs tasks across several threads (independent lines of execution happening in parallel), coordinating those threads safely is a known source of bugs. Crossbeam provides building blocks that handle the tricky parts correctly so developers do not have to implement them from scratch. The library is organized into several areas. One area covers atomic types, which are memory locations that multiple threads can read and write to at the same time without corrupting each other's data. Another area covers data structures designed for concurrent use: queues where multiple threads can add and remove items simultaneously, and work-stealing deques, which are used to build task schedulers where idle threads can pull work from other threads that have a backlog. A third area covers thread synchronization. This includes channels, which are a way for threads to send messages to each other, similar to how you might pass notes between workers in separate rooms. There is also a reader-writer lock optimized for situations where many threads need to read data at the same time but writes are rare, and a WaitGroup that lets one thread wait until a set of other threads has finished its work. The library also includes memory management utilities. Epoch-based garbage collection is a technique for safely freeing memory that other threads might still be accessing, and it comes up often when building the kind of lock-free data structures Crossbeam targets. There are also utilities for controlling how data is laid out in CPU cache memory, which matters for performance in tight loops. Crossbeam is organized as a collection of smaller packages grouped under one main package. Each sub-package can be used independently. The library requires Rust version 1.74 or later and is available under the MIT or Apache 2.0 license.

Copy-paste prompts

Prompt 1

Show me how to use crossbeam's multi-producer multi-consumer channel to distribute work items from one Rust thread to a pool of worker threads.

Prompt 2

Write a Rust example using crossbeam's work-stealing deque to build a simple parallel task scheduler where idle threads pull from busy ones.

Prompt 3

How do I use crossbeam's epoch-based garbage collection to safely free shared memory in a lock-free data structure in Rust?

Prompt 4

Replace std::sync::RwLock with crossbeam's ShardedLock in my Rust HTTP server and show me how the API differs.

Open on GitHub → Explain another repo

← crossbeam-rs on gitmyhub — every repo by this author, as a profile.

Verify against the repo before relying on details.