taskq 0.1.0

A thread-safe in-memory task queue with async consumption and optional idempotency keys
Documentation
use std::sync::{
    Arc, Barrier, Mutex,
    atomic::{AtomicUsize, Ordering},
};
use std::thread;

use taskq::{SimpleTaskQueue, TaskState};

#[test]
fn public_queue_api_supports_multiple_producers_and_consumers() {
    let producer_count = 4;
    let consumer_count = 4;
    let tasks_per_producer = 250;
    let total_tasks = producer_count * tasks_per_producer;

    let queue = Arc::new(SimpleTaskQueue::<Vec<u8>>::new());
    let start = Arc::new(Barrier::new(producer_count + consumer_count));
    let produced = Arc::new(AtomicUsize::new(0));
    let consumed = Arc::new(AtomicUsize::new(0));
    let task_ids = Arc::new(Mutex::new(Vec::with_capacity(total_tasks)));

    thread::scope(|scope| {
        for producer_id in 0..producer_count {
            let queue = Arc::clone(&queue);
            let start = Arc::clone(&start);
            let produced = Arc::clone(&produced);
            let task_ids = Arc::clone(&task_ids);

            scope.spawn(move || {
                start.wait();

                for _ in 0..tasks_per_producer {
                    let task_id = queue.submit_task(vec![producer_id as u8]).unwrap();
                    task_ids.lock().unwrap().push(task_id);
                    produced.fetch_add(1, Ordering::Release);
                }
            });
        }

        for _ in 0..consumer_count {
            let queue = Arc::clone(&queue);
            let start = Arc::clone(&start);
            let consumed = Arc::clone(&consumed);

            scope.spawn(move || {
                start.wait();

                while consumed.load(Ordering::Acquire) < total_tasks {
                    let task = queue.try_pop_task();

                    if let Some(task) = task {
                        queue.mark_task_success(task.id()).unwrap();
                        consumed.fetch_add(1, Ordering::AcqRel);
                    } else {
                        thread::yield_now();
                    }
                }
            });
        }
    });

    assert_eq!(produced.load(Ordering::Acquire), total_tasks);
    assert_eq!(consumed.load(Ordering::Acquire), total_tasks);

    let mut task_ids = task_ids.lock().unwrap().clone();
    task_ids.sort_unstable();
    task_ids.dedup();
    assert_eq!(task_ids.len(), total_tasks);
    for task_id in task_ids {
        let status = queue.get_task_status(task_id).unwrap();
        assert_eq!(status.state(), TaskState::Success);
        assert!(status.finished_at().is_some());
    }
}