Tag
33 posts
A hung async service has no useful thread backtrace. Tokio task dumps capture the await stack of every task. Enable tokio_unstable and taskdump, trigger a dump from a signal or endpoint, and read where each task is parked.
A task that hangs forever has a short list of causes: a channel sender that never drops, an await on a lock held across an await, a blocked worker, a missing timeout, or a lost wake-up.
Pick a background job system for a Rust service: an in-process Tokio channel, a database table with SKIP LOCKED, Redis queues, or a broker. Compare durability, retries, scale and operational cost.
Tokio spawn needs a Send future. When the compiler says the future cannot be sent between threads safely, it points at the value held across an await.
A MutexGuard held across an await can make a task non-Send or deadlock a worker. See the compiler error, the deadlock it allows and three fixes.
Use std::sync::Mutex when the lock is never held across an await and tokio::sync::Mutex when it must be. The std one is faster and is the default choice.
Tokio has four channel types: mpsc, oneshot, broadcast and watch. Pick by how many senders and receivers you have and whether late messages matter.
tokio::time::timeout drops the future when time runs out, which is not the same as stopping the work behind it. Learn what actually gets cancelled.
One blocking call inside an async task can freeze a worker thread. See how it happens, how to find it and the three fixes: spawn_blocking, a thread, or async APIs.
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.
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.
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.