Concurrency
Tokio Semaphores for Limiting Concurrency in Rust Services
A Semaphore hands out a fixed number of permits so only N tasks run a section at once. See acquire, owned permits, fairness and common limits to set.
7 min read
Topic
Concurrency
Threads, channels, locks, atomics and Tokio, with a bias towards the bug you will hit at 3am.
Concurrency
Sharing State in Tokio With Arc Mutex and Message Passing
Share state in async code with Arc<Mutex<T>>, with a state owning task and channels, or with read heavy structures. See the trade-offs and the failure modes.
7 min read
Concurrency
Bounded Channels and Backpressure in Tokio Done Explained
A bounded channel makes a fast producer wait for a slow consumer. See capacity, send().await, try_send, and how to choose a size that does not hide overload.
7 min read
Concurrency
Graceful Shutdown in Tokio With Signals and Task Tracking
Shut down a Tokio service cleanly: catch SIGTERM and Ctrl+C, stop accepting work, wait for in flight tasks with TaskTracker, then exit within a deadline.
7 min read
Concurrency
Cancelling Tasks in Tokio With Abort and Cancellation Tokens
Stop a Tokio task three ways: JoinHandle::abort, a CancellationToken for cooperative shutdown, and dropping a future. See what each does to cleanup.
7 min read
Concurrency
Tokio Select and Cancellation Safety Explained With Traps
select! races futures and drops the losers, which is only safe if they can be dropped mid way. Learn what cancellation safe means and which APIs are not.
7 min read
Concurrency
Spawn Blocking in Tokio and When Rayon Is the Better Tool
Both move blocking work off the async threads, but they differ in pool, limits and fit. See which to pick for file I/O, hashing and number crunching.
7 min read
Concurrency
JoinSet in Tokio for Managing Many Tasks as a Group
JoinSet owns a group of spawned tasks and returns their results as they finish. See spawn, join_next, abort_all and how errors and panics surface.
8 min read
Concurrency
Why Tokio Spawn Needs a Static Future and How to Cope
tokio::spawn demands a future that owns its data. Learn why the compiler asks for static, what it does and does not mean, and four ways to share data with a task.
7 min read
Concurrency
Async and Await in Rust and What the Compiler Generates
async and await are syntax over futures. Learn what async blocks capture, where await may appear, how errors and ? work, and the common first mistakes.
7 min read
Concurrency
Futures in Rust Explained as State Machines You Can Read
An async fn compiles to a state machine that implements Future. See the generated shape, what poll does, and why a future does nothing until it is polled.
8 min read
Concurrency
Spawning Tasks With tokio spawn and Joining Their Results
Spawn tasks with tokio::spawn, wait for them with JoinHandle and collect results with JoinSet. Includes the Send and static bounds and the panics join returns.
8 min read
Get new posts by email
We send one email when a new post is published. No spam.