چالش های پیاده سازی ratelimiter برای یک CDN - قسمت ۲

fn do_work(lock: &Arc<Mutex<()>>, no_lock: bool) -> usize {
    let _lock_guard;
    if !no_lock {
        _lock_guard = lock.lock();
    }
    let mut result = 0;
    for i in 1..=1000 {
        result += i;
    }
    result
}

pub struct WebServer {
    threads: Vec<(usize, Sender<()>, JoinHandle<usize>)>,
}

impl WebServer {
    pub fn new(num_threads: usize, no_lock: bool) -> Self {
        let lock = Arc::new(Mutex::new(()));
        let threads: Vec<_> = (1..=num_threads)
            .map(|i| {
                let (tx, rx) = mpsc::channel::<()>();
                let lock = Arc::clone(&lock);
                let handle = std::thread::spawn(move || {
                    let lock = lock;
                    let mut total = 0;
                    while let Ok(_) = rx.recv() {
                        total += do_work(&lock, no_lock);
                    }
                    total
                });
                (i, tx, handle)
            })
            .collect();
        WebServer { threads }
    }

    pub fn send_work(&self, num_works: usize) {
        // --snip--
    }

    pub fn shutdown(mut self) {
        // --snip--
    }

}

$ cargo run --release
with lock took 20.474073198s
without lock took 3.526799261s

$ cargo flamegraph -c 'perf record -F 997 --call-graph dwarf -g'

[ perf record: Woken up 3009 times to write data ]
Warning:
Processed 218901 events and lost 4 chunks!

Check IO/CPU overload!

[ perf record: Captured and wrote 759.438 MB perf.data (92749 samples) ]
writing flamegraph to "flamegraph.svg

$ open flamegraph.svg