mini-io-queue

固定长度、分配和锁-free、面向异步 I/O 的单生产者单消费者（SPSC）队列。

概述

该库提供几个基于相同核心的固定长度队列，用于不同的用例。

• asyncio 是一个使用 futures 的泛型异步、线程安全、锁-free 队列。读操作可以在数据可用之前暂停，写操作可以在有空间返回之前暂停。该队列可以作为高效的 I/O 缓冲区使用，具有 futures::AsyncRead 和 futures::AsyncWrite 实现。
• blocking 是一个泛型线程安全队列。读操作可以在数据可用之前阻塞，写操作可以在有空间返回之前阻塞。该队列可以作为高效的 I/O 缓冲区使用，具有 io::Read 和 io::Write 实现。
• nonblocking 是一个泛型线程安全、锁-free 队列，保证不会阻塞。在读写速度匹配或没有锁的情况下，它可以作为高效的 I/O 缓冲区使用。

所有队列都有独立的 Reader 和 Writer 端，可以在线程之间发送。队列设计时考虑到批量操作，因此可以安全地与大型读/写操作一起使用，例如在字节数组 I/O 上下文中。

该库还提供了 Ring，这是一个低级原子环形缓冲区构建块，用于实现各种队列。

该库支持 no_std，具有减少的功能集，并且可高度配置。使用默认功能集时，它不需要任何依赖项。

示例

简单的异步示例

use futures::executor::block_on;
use futures::join;
use mini_io_queue::asyncio::queue;

let (mut reader, mut writer) = queue(8);

let write_loop = async {
    for i in 0..16 {
        writer.write_all(&[i]).await.unwrap();
    }
};

let read_loop = async {
    for i in 0..16 {
        let mut buf = [0];
        reader.read_exact(&mut buf).await.unwrap();

        assert_eq!(buf[0], i);
    }
};

block_on(async { join!(write_loop, read_loop) });

带有自定义环的阻塞队列

use mini_io_queue::blocking::queue_from_parts;
use mini_io_queue::Ring;
use mini_io_queue::storage::{HeapBuffer, Storage};

// Create a queue with half of the underlying buffer in the read side.
let ring = Ring::new(10);
ring.advance_right(5);

let mut buffer = HeapBuffer::new(10);
buffer.slice_mut(0..5).copy_from_slice(&[1, 2, 3, 4, 5]);

let (mut reader, _) = queue_from_parts(ring, buffer);

for i in 1..=5 {
    let mut buf = [0];
    reader.read_exact(&mut buf).unwrap();
    assert_eq!(buf[0], i);
}

许可证

在 MIT 许可证下提供。有关详细信息，请参阅 LICENSE 文件。