The best practice for using the blocking mutex in the asynchronous context

[vvvviiv]

As the doc of tokio::sync::Mutex said:

tokio/tokio/src/sync/mutex.rs

Lines 26 to 27 in 5ea3c63

	/// Contrary to popular belief, it is ok and often preferred to use the ordinary
	/// [`Mutex`][std] from the standard library in asynchronous code.

And since Tokio provides block_in_place:

tokio/tokio/src/task/blocking.rs

Lines 4 to 5 in 5ea3c63

	/// Runs the provided blocking function on the current thread without
	/// blocking the executor.

which is suitable for synchronous contexts:

tokio/tokio/src/task/blocking.rs

Lines 23 to 25 in 5ea3c63

	/// to. On the other hand, calling the function outside a runtime is
	/// allowed. In this case, `block_in_place` just calls the provided closure
	/// normally.

We have two ways to lock a blocking mutex:

1. Call the blocking lock method directly:

   #[tokio::main]
   async fn main() {
       let mutex = std::sync::Mutex::new(String::new());
   
       *mutex.lock().unwrap() = "hello world".to_string();
   }

2. Call the blocking lock method inside block_in_place:

   #[tokio::main]
   async fn main() {
       let mutex = std::sync::Mutex::new(String::new());
   
       tokio::task::block_in_place(|| {
           *mutex.lock().unwrap() = "hello world".to_string();
       });
   }

The second approach may be better as it avoids blocking the executor.

Do I understand this correctly? Thanks for your help.

[Darksonn]

When using a blocking mutex, you must ensure that the call to lock takes a short amount of time. And if it does that, it's not really blocking.

Using block_in_place is a bad idea. The way it works is that a new worker thread is spawned in the background. It's not a magic bullet and it can be really expensive. If locking the mutex takes a short amount of time, then it is unnecessary. If locking the mutex takes a long time, you should use tokio::sync::Mutex instead of block_in_place.

[vvvviiv]

That's really helpful, thank you!