Rust高性能计数器库fast-counter的使用

介绍

fast-counter是一个Rust语言的高性能计数器库，提供了快速且线程安全的计数器功能。它专为需要高性能计数操作的场景设计，特别适合多线程环境下的统计计数需求。

主要特点：

• 线程安全：内部使用原子操作实现，无需额外同步
• 高性能：比标准库的原子类型有更好的优化
• 简单易用：提供直观的API接口
• 低开销：最小化内存和CPU使用

安装

在Cargo.toml中添加依赖：

[dependencies]
fast-counter = "0.2"

基本使用方法

创建计数器

use fast_counter::Counter;

let counter = Counter::new(0); // 从0开始计数

基本操作

// 增加计数
counter.inc(); // 增加1
counter.inc_by(5); // 增加指定值

// 减少计数
counter.dec(); // 减少1
counter.dec_by(3); // 减少指定值

// 获取当前值
let current = counter.get();

多线程示例

use fast_counter::Counter;
use std::sync::Arc;
use std::thread;

let counter = Arc::new(Counter::new(0));
let mut handles = vec![];

for _ in 0..10 {
    let counter = Arc::clone(&counter);
    let handle = thread::spawn(move || {
        for _ in 0..1000 {
            counter.inc();
        }
    });
    handles.push(handle);
}

for handle in handles {
    handle.join().unwrap();
}

assert_eq!(counter.get(), 10000);

高级功能

重置计数器

counter.reset(); // 重置为0
counter.reset_to(42); // 重置为指定值

比较并交换(CAS)操作

// 只有当当前值为10时才设置为20
let success = counter.compare_and_swap(10, 20);

获取并增加

let prev_value = counter.get_and_inc(); // 获取当前值并增加1
let prev_value = counter.get_and_add(5); // 获取当前值并增加5

性能建议

1. 对于单线程应用，可以考虑使用普通的整数类型
2. 对于高并发场景，fast-counter比标准库的AtomicUsize有更好的性能
3. 批量操作时使用inc_by/dec_by比多次调用inc/dec更高效

基准测试示例

use fast_counter::Counter;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::time::Instant;

let fast_counter = Counter::new(0);
let atomic_counter = AtomicUsize::new(0);

let start = Instant::now();
for _ in 0..1_000_000 {
    fast_counter.inc();
}
println!("fast-counter耗时: {:?}", start.elapsed());

let start = Instant::now();
for _ in 0..1_000_000 {
    atomic_counter.fetch_add(1, Ordering::SeqCst);
}
println!("AtomicUsize耗时: {:?}", start.elapsed());

完整示例代码

use fast_counter::Counter;
use std::sync::Arc;
use std::thread;

fn main() {
    // 创建计数器
    let counter = Counter::new(0);
    
    // 基本操作演示
    counter.inc();
    println!("After inc(): {}", counter.get()); // 1
    
    counter.inc_by(5);
    println!("After inc_by(5): {}", counter.get()); // 6
    
    counter.dec();
    println!("After dec(): {}", counter.get()); // 5
    
    counter.dec_by(2);
    println!("After dec_by(2): {}", counter.get()); // 3
    
    // 重置演示
    counter.reset();
    println!("After reset: {}", counter.get()); // 0
    
    counter.reset_to(100);
    println!("After reset_to(100): {}", counter.get()); // 100
    
    // CAS操作演示
    let success = counter.compare_and_swap(100, 200);
    println!("CAS success: {}, new value: {}", success, counter.get()); // true, 200
    
    // 获取并增加演示
    let prev = counter.get_and_add(10);
    println!("get_and_add: previous={}, current={}", prev, counter.get()); // 200, 210
    
    // 多线程演示
    let shared_counter = Arc::new(Counter::new(0));
    let mut handles = vec![];
    
    for _ in 0..5 {
        let counter = Arc::clone(&shared_counter);
        handles.push(thread::spawn(move || {
            for _ in 0..10000 {
                counter.inc();
            }
        }));
    }
    
    for handle in handles {
        handle.join().unwrap();
    }
    
    println!("Final counter value: {}", shared_counter.get()); // 50000
}

这个完整示例演示了fast-counter库的所有主要功能：

1. 基本计数操作（增加/减少）
2. 重置计数器
3. CAS操作
4. 获取并增加操作
5. 多线程环境下的使用

运行此程序将展示计数器在不同操作下的值变化，以及最终在多线程环境中正确累加的结果。