Initialize the HashMap

The HashMap will be shared across many tasks and potentially many threads. To support this, it is wrapped in Arc<Mutex<_>>.

First, for convenience, add the following type alias after the use statements.

  1. use bytes::Bytes;
  2. use std::collections::HashMap;
  3. use std::sync::{Arc, Mutex};
  5. type Db = Arc<Mutex<HashMap<String, Bytes>>>;

Then, update the main function to initialize the HashMap and pass an Arc handle to the process function. Using Arc allows the HashMap to be referenced concurrently from many tasks, potentially running on many threads. Throughout Tokio, the term handle is used to reference a value that provides access to some shared state.

  1. use tokio::net::TcpListener;
  2. use std::collections::HashMap;
  3. use std::sync::{Arc, Mutex};
  5. #[tokio::main]
  6. async fn main() {
  7.     let listener = TcpListener::bind("127.0.0.1:6379").await.unwrap();
  9.     println!("Listening");
  11.     let db = Arc::new(Mutex::new(HashMap::new()));
  13.     loop {
  14.         let (socket, _) = listener.accept().await.unwrap();
  15.         // Clone the handle to the hash map.
  16.         let db = db.clone();
  18.         println!("Accepted");
  19.         tokio::spawn(async move {
  20.             process(socket, db).await;
  21.         });
  22.     }
  23. }

On using std::sync::Mutex

Note, std::sync::Mutex and not tokio::sync::Mutex is used to guard the HashMap. A common error is to unconditionally use tokio::sync::Mutex from within async code. An async mutex is a mutex that is locked across calls to .await.

A synchronous mutex will block the current thread when waiting to acquire the lock. This, in turn, will block other tasks from processing. However, switching to tokio::sync::Mutex usually does not help as the asynchronous mutex uses a synchronous mutex internally.

As a rule of thumb, using a synchronous mutex from within asynchronous code is fine as long as contention remains low and the lock is not held across calls to .await. Additionally, consider using parking_lot::Mutex as a faster alternative to std::sync::Mutex.