How to create a async HashMap singleton

[leenux]

I wanna create a async HashMap singleton, So any where can use it in my project.
The pseudo code:

static_or_lazy MY_SINGLETON Arc_or_noArc<tokio::sync::RwLock<HashMap<String, String>>> = ?
#tokio_main
fn main() {
    tokio::spawn(async move {
            how_to_get_MY_SINGLETON_item.await;  //?
        });
    tokio::spawn(async move {
            how_to_store_MY_SINGLETON_item.await;  //?
        });
}

[Darksonn]

The shared state chapter in the Tokio tutorial covers this. As for making it a global variable, you can do this with lazy_static!.

use std::sync::Mutex;
use std::collections::HashMap;

lazy_static! {
    static ref MY_SINGLETON: Mutex<HashMap<String, String>> = Mutex::new(HashMap::new());
}

Note that when using lazy_static!, you do not need an Arc. The purpose of an Arc is to share the variable, but we already get this from lazy_static!.

Note also that you should not be using an tokio::sync lock for this, but rather an std::sync lock. Please read the shared state chapter that I linked for an explanation of why. As for RwLock vs Mutex, you should prefer a Mutex, and if that doesn't do the job, use the dashmap crate instead of switching to an RwLock.

[leenux]

@Darksonn
I'm very interested in dashmap,But it doesn't look asynchronous.Maybe I should encapsulate every action(insert,get, etc)as an asynchronous task.

[Darksonn]

Just because its methods are not marked async does not mean using dashmap is a problem. Non-async methods are only a problem if they block for an extended period of time (see more here). The only thing you need to avoid is keeping a lock across an .await, which you can read more about in the shared state chapter I linked above.

Encapsulating every action is a fine idea, but you do not have to mark them async. See again the shared state chapter, in particular the section on Restructure your code to not hold the lock across an .await for an example.