出于好奇，我写了下面的程序，它每秒滴答X次，应该非常接近目标滴答数，但不知何故，它总是落后很多。
例如，对于一个2秒的基准测试，输出是（它应该是2*64 -> 128）。在发布模式下构建并不能解决这个问题：

Starting benchmark 2s with length
Benchmark started.
Ticked 83 in 2 seconds

字符串
其他长度也是一样的，例如5秒产生196，应该是320。实际上应该更多，因为我让它运行多一点。
是因为Arc Mutex速度慢，还是还有其他原因？瓶颈在哪里？

use std::{ time::{ SystemTime, UNIX_EPOCH }, sync::Arc };

use tokio::{ time::{ sleep, Duration }, sync::Mutex };

const TICK_COUNT: u64 = 64;
const BENCHMARK_LENGTH: u64 = 2;

#[tokio::main]
async fn main() {
    let tick_count = 0;
    let interval = 1000 / TICK_COUNT;

    let shared = Arc::new(Mutex::new(tick_count));

    let start_time = SystemTime::now();

    println!("Starting benchmark {}s with length", BENCHMARK_LENGTH);

    let displayed = shared.clone();
    let incrementer = shared.clone();

    tokio::spawn(async move {
        loop {
            if
                start_time.duration_since(UNIX_EPOCH).unwrap() +
                    Duration::from_secs(BENCHMARK_LENGTH) <
                SystemTime::now().duration_since(UNIX_EPOCH).unwrap()
            {
                println!("Ticked {} in {} seconds", displayed.lock().await, BENCHMARK_LENGTH);

                std::process::exit(0);
            }

            sleep(Duration::from_millis(500)).await;
        }
    });

    tokio::spawn(async move {
        loop {
            sleep(Duration::from_millis(interval)).await;

            *incrementer.lock().await += 1;
        }
    });

    let _ = tokio::spawn(async move {
        println!("Benchmark started.");
        loop {
            sleep(Duration::from_secs(1)).await;
        }
    }).await;
}

型