future cannot be sent between threads safely

use std::sync::{Arc, Mutex};
use std::time::Duration;

#[tokio::main]
async fn main() {
  let counter = Arc::new(Mutex::new(0u64));
  let c = counter.clone();
  tokio::spawn(async move {
    let mut guard = c.lock().unwrap();
    *guard += 1;
    tokio::time::sleep(Duration::from_millis(10)).await;
    println!("{}", *guard);
  })
  .await
  .unwrap();
}

error: future cannot be sent between threads safely
   --> src/bin/ns_guard.rs:8:3
    |
  8 | /   tokio::spawn(async move {
  9 | |     let mut guard = c.lock().unwrap();
 10 | |     *guard += 1;
 11 | |     tokio::time::sleep(Duration::from_millis(10)).await;
 12 | |     println!("{}", *guard);
 13 | |   })
    | |____^ future created by async block is not `Send`
    |
    = help: within `{async block@src/bin/ns_guard.rs:8:16: 8:26}`, the trait `Send` is not implemented for `std::sync::MutexGuard<'_, u64>`
note: future is not `Send` as this value is used across an await
   --> src/bin/ns_guard.rs:11:51
    |
  9 |     let mut guard = c.lock().unwrap();
    |         --------- has type `std::sync::MutexGuard<'_, u64>` which is not `Send`
 10 |     *guard += 1;
 11 |     tokio::time::sleep(Duration::from_millis(10)).await;
    |                                                   ^^^^^ await occurs here, with `mut guard` maybe used later
note: required by a bound in `tokio::spawn`
   --> ~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tokio-1.54.1/src/task/spawn.rs:176:21
    |
174 |     pub fn spawn<F>(future: F) -> JoinHandle<F::Output>
    |            ----- required by a bound in this function
175 |     where
176 |         F: Future + Send + 'static,
    |                     ^^^^ required by this bound in `spawn`

    = help: within `{async block@src/bin/ns_rc.rs:5:16: 5:21}`, the trait `Send` is not implemented for `Rc<String>`
note: future is not `Send` as this value is used across an await
   --> src/bin/ns_rc.rs:7:30
    |
  6 |     let name = Rc::new("job".to_string());
    |         ---- has type `Rc<String>` which is not `Send`
  7 |     tokio::task::yield_now().await;
    |                              ^^^^^ await occurs here, with `name` maybe used later

// 通过：块作用域
{
  let mut guard = c.lock().unwrap();
  *guard += 1;
} // guard dropped here
tokio::time::sleep(Duration::from_millis(10)).await;

// 通过：语句里的临时值，到 `;` 就销毁
*c.lock().unwrap() += 1;
tokio::time::sleep(Duration::from_millis(10)).await;

// 通过：if 条件里的临时值，进入分支前销毁
if *c.lock().unwrap() == 0 {
  tokio::time::sleep(Duration::from_millis(10)).await;
}

// 通过：在同步函数里加锁，返回普通值
let n = bump(&c); // fn bump(c: &Mutex<u64>) -> u64 { let mut g = c.lock().unwrap(); *g += 1; *g }
tokio::time::sleep(Duration::from_millis(n)).await;

// 报错：drop(guard) 之后再 await
let mut guard = c.lock().unwrap();
*guard += 1;
drop(guard);
tokio::time::sleep(Duration::from_millis(10)).await;

// 报错：只在某个分支里 drop
let guard = c.lock().unwrap();
if *guard == 0 {
  drop(guard);
}
tokio::time::sleep(Duration::from_millis(10)).await;

// 报错：match 的被匹配表达式里的临时值，活到整个 match 结束
match *c.lock().unwrap() {
  0 => tokio::time::sleep(Duration::from_millis(10)).await,
  _ => {}
}

// 报错：if let 同理
if let 0 = *c.lock().unwrap() {
  tokio::time::sleep(Duration::from_millis(10)).await;
}

let c = Arc::new(tokio::sync::Mutex::new(0u64));
let c2 = c.clone();
tokio::spawn(async move {
  let mut guard = c2.lock().await;
  *guard += 1;
  tokio::time::sleep(Duration::from_millis(10)).await;
  *guard += 1;
})
.await
.unwrap();
println!("tokio Mutex across await: {}", *c.lock().await);

let local = tokio::task::LocalSet::new();
local
  .run_until(async {
    tokio::task::spawn_local(async {
      let name = Rc::new("job".to_string());
      tokio::task::yield_now().await;
      println!("spawn_local with Rc across await: {name}");
    })
    .await
    .unwrap();
  })
  .await;

tokio Mutex across await: 2
spawn_local with Rc across await: job