2 unstable releases

0.2.0 Dec 26, 2020
0.1.0 Jan 21, 2020

#13 in #queue

Download history 105/week @ 2020-11-10 133/week @ 2020-11-17 100/week @ 2020-11-24 140/week @ 2020-12-01 157/week @ 2020-12-08 115/week @ 2020-12-15 149/week @ 2020-12-22 151/week @ 2020-12-29 164/week @ 2021-01-05 184/week @ 2021-01-12 358/week @ 2021-01-19 489/week @ 2021-01-26 347/week @ 2021-02-02 611/week @ 2021-02-09 1048/week @ 2021-02-16 769/week @ 2021-02-23

476 downloads per month


303 lines

Deadqueue Latest Version Build Status

Deadqueue is a dead simple async queue with back pressure support.

This crate provides three implementations:

  • Unlimited (deadqueue::unlimited::Queue)

    • Based on crossbeam_queue::SegQueue
    • Has unlimitied capacity and no back pressure on push
    • Enabled via the unlimited feature in your Cargo.toml
  • Resizable (deadqueue::resizable::Queue)

    • Based on deadqueue::unlimited::Queue
    • Has limited capacity with back pressure on push
    • Supports resizing
    • Enabled via the resizable feature in your Cargo.toml
  • Limited (deadqueue::limited::Queue)

    • Based on crossbeam_queue::ArrayQueue
    • Has limit capacity with back pressure on push
    • Does not support resizing
    • Enabled via the limited feature in your Cargo.toml


Feature Description Extra dependencies Default
unlimited Enable unlimited queue implementation yes
resizable Enable resizable queue implementation deadqueue/unlimited yes
limited Enable limited queue implementation yes


use std::sync::Arc;

const TASK_COUNT: usize = 1000;
const WORKER_COUNT: usize = 10;

type TaskQueue = deadqueue::limited::Queue<usize>;

async fn main() {
    let queue = Arc::new(TaskQueue::new(10));
    for i in 0..TASK_COUNT {
    let mut futures = Vec::new();
    for _ in 0..WORKER_COUNT {
        let queue = queue.clone();
        futures.push(tokio::spawn(async move {
            let task = queue.pop().await;
            assert!(task > 1);
    for future in futures {
    assert_eq!(queue.len(), 0);

Reasons for yet another queue

Deadqueue is by no means the only queue implementation available. It does things a little different and provides features that other implementations are lacking:

  • Resizable queue. Usually you have to pick between limited and unlimited queues. This crate features a resizable Queue which can be resized as needed. This is probably a big unique selling point of this crate.

  • Introspection support. The methods .len(), .capacity() and .available() provide access the current state of the queue.

  • Fair scheduling. Tasks calling pop will receive items in a first-come-first-serve fashion. This is mainly due to the use of tokio::sync::Semaphore which is fair by nature.

  • One struct, not two. The channels of tokio, async_std and futures-intrusive split the queue in two structs (Sender and Receiver) which makes the usage sligthly more complicated.

  • Bring your own Arc. Since there is no separation between Sender and Receiver there is also no need for an internal Arc. (All implementations that split the channel into a Sender and Receiver need some kind of Arc internally.)

  • Fully concurrent access. No need to wrap the Receiver part in a Mutex. All methods support concurrent accesswithout the need for an additional synchronization primitive.

  • Support for try__ methods. The methods try_push and try_pop can be used to access the queue from non-blocking synchroneous code.


Crate Limitations Documentation
tokio No resizable queue. No introspection support. Synchronization of Receiver needed. tokio::sync::mpsc::channel, tokio::sync::mpsc::unbounded_channel
async-std No resizable or unlimited queue. No introspection support. No try_send or try_recv methods. async_std::sync::channel
futures No resizable queue. No introspection support. futures::channel::mpsc::channel, futures::channel::mpsc::unbounded


Licensed under either of

at your option.


~27K SLoC