Rust高性能IO计数器库countio使用指南

countio是一个轻量级、高效的Rust库，专门用于统计字节流的读写操作。它通过包装标准I/O类型来透明地记录传输的字节数，非常适合需要监控I/O使用情况的场景。

主要特性

• 轻量级包装器设计，几乎零开销
• 支持所有标准I/O类型（Read/Write/BufRead等）
• 线程安全，内部使用原子计数器
• 可随时查询当前统计值而不中断I/O操作

基本使用方法

添加依赖

首先在Cargo.toml中添加依赖：

[dependencies]
countio = "0.3"

基本示例

use countio::CountIo;
use std::io::{Read, Write};

fn main() -> std::io::Result<()> {
    // 包装一个Vec<u8>作为写入目标
    let mut buf = vec![];
    let mut writer = CountIo::new(&mut buf);
    
    // 写入数据
    writer.write_all(b"Hello, world!")?;
    
    // 获取写入字节数
    println!("Bytes written: {}", writer.count());
    
    // 包装一个读取器
    let data = b"Some data to read";
    let mut reader = CountIo::new(&data[..]);
    
    let mut dest = [0; 5];
    reader.read_exact(&mut dest)?;
    
    // 获取读取字节数
    println!("Bytes read: {}", reader.count());
    
    Ok(())
}

高级用法

组合使用

use countio::CountIo;
use std::io::{BufRead, BufReader, Cursor};

fn main() {
    let data = "Line 1\nLine 2\nLine 3".as_bytes();
    let reader = BufReader::new(Cursor::new(data));
    let mut counting_reader = CountIo::new(reader);
    
    let mut lines = 0;
    let mut buffer = String::new();
    
    while counting_reader.read_line(&mut buffer).unwrap() > 0 {
        lines += 1;
        buffer.clear();
    }
    
    println!("Read {} lines ({} bytes)", lines, counting_reader.count());
}

重置计数器

use countio::CountIo;
use std::io::Write;

fn main() {
    let mut output = vec![];
    let mut writer = CountIo::new(&mut output);
    
    writer.write_all(b"First write").unwrap();
    println!("Count after first write: {}", writer.count());
    
    writer.reset_count();
    
    writer.write_all(b"Second write").unwrap();
    println!("Count after second write: {}", writer.count());
}

多线程使用

use countio::CountIo;
use std::io::Write;
use std::sync::Arc;
use std::thread;

fn main() {
    let output = Arc::new(std::sync::Mutex::new(vec![]));
    let writer = CountIo::new(Arc::clone(&output));
    
    let handles: Vec<_> = (0..4).map(|i| {
        let mut writer = writer.try_clone().unwrap();
        thread::spawn(move || {
            writer.write_all(format!("Thread {} data\n", i).as_bytes()).unwrap();
        })
    }).collect();
    
    for handle in handles {
        handle.join().unwrap();
    }
    
    println!("Total bytes written: {}", writer.count());
    println!("Output: {:?}", String::from_utf8_lossy(&output.lock().unwrap()));
}

完整示例demo

下面是一个完整的文件读写统计示例，展示了如何使用countio监控文件操作：

use countio::CountIo;
use std::fs::File;
use std::io::{self, BufReader, BufWriter, Read, Write};

fn main() -> io::Result<()> {
    // 1. 写入文件并统计字节数
    let file = File::create("example.txt")?;
    let mut writer = CountIo::new(BufWriter::new(file));
    
    // 写入多行数据
    for i in 1..=5 {
        writeln!(writer, "这是第{}行文本数据", i)?;
    }
    
    // 强制刷新缓冲区确保数据写入
    writer.flush()?;
    
    println!("写入文件完成，总字节数: {}", writer.count());
    
    // 2. 读取同一文件并统计字节数
    let file = File::open("example.txt")?;
    let mut reader = CountIo::new(BufReader::new(file));
    
    let mut content = String::new();
    reader.read_to_string(&mut content)?;
    
    println!("\n文件内容:\n{}", content);
    println!("读取文件完成，总字节数: {}", reader.count());
    
    // 3. 多线程写入示例
    println!("\n多线程写入示例:");
    let shared_writer = CountIo::new(io::stdout());
    
    let handles: Vec<_> = (0..3).map(|i| {
        let mut writer = shared_writer.try_clone().unwrap();
        std::thread::spawn(move || {
            writeln!(writer, "线程{}写入的数据", i).unwrap();
        })
    }).collect();
    
    for handle in handles {
        handle.join().unwrap();
    }
    
    println!("多线程总写入字节数: {}", shared_writer.count());
    
    Ok(())
}

性能考虑

countio设计时考虑了最小化性能影响：

• 使用原子操作保证线程安全
• 计数器只在I/O操作时更新
• 无额外内存分配

对于极端性能敏感的场景，建议进行基准测试，但大多数情况下开销可以忽略不计。

适用场景

• 网络传输监控
• 文件处理进度跟踪
• 数据流分析
• 调试I/O密集型操作
• 资源使用统计

countio通过简单透明的包装为Rust程序提供了便捷的I/O统计功能，是监控和分析I/O行为的理想工具。