Início / coding / Perguntas / 78832522
Accepted
zhaokai xie
Asked: 2024-08-05 10:17:01 +0800 CST

função assíncrona como tipo de valor hashmap

  • 772

Quero armazenar algumas operações aysnc em um hashmap. Em seguida, obtenha uma lista de operações assíncronas com base na lista de strings de entrada do usuário. Pesquisando no site, encontrei esta pergunta

Como posso colocar uma função assíncrona em um mapa no Rust?

A diferença é que eu quero usar o hashmap da operação armazenada em diferentes threads do Tokio. Então eu reescrevo com once_cell + RwLock.

Exemplo completo

static MAPS: Lazy<Arc<RwLock<HashMap<&'static str, CalcFn>>>> = Lazy::new(|| {
    let map = Arc::new(RwLock::new(HashMap::new()));
    let mut map_lock = map.write().unwrap();
    map_lock.insert(
        "add",
        Box::new(
            move |a: i32, b: i32| -> Pin<Box<dyn Future<Output = BoxedResult<i32>>>> {
                Box::pin(add(a, b))
            },
        ) as CalcFn,
    );
    map_lock.insert(
        "sub",
        Box::new(
            move |a: i32, b: i32| -> Pin<Box<dyn Future<Output = BoxedResult<i32>>>> {
                Box::pin(sub(a, b))
            },
        ) as CalcFn,
    );
    map.clone()
});

A inicialização lenta parece chata e ocupa muitas linhas de código porque posso ter mais de 20 operações assíncronas.

Alguém poderia gentilmente oferecer alguns comentários para escrever este exemplo de uma forma "mais limpa"?

asynchronous

1 respostas

  1. Best Answer

    A primeira coisa a fazer é passar o máximo possível da operação de inserção para outra função.

    fn insert_async_fn<K, F, Fut>(map: &mut HashMap<K, CalcFn>, name: K, f: F)
where
    K: Eq + Hash,
    F: Fn(i32, i32) -> Fut + Send + Sync + 'static,
    Fut: Future<Output = BoxedResult<i32>> + Send + 'static,
{
    map.insert(name, Box::new(move |a, b| Box::pin(f(a, b))));
}

// Used like this
insert_async_fn(&mut map, "add", add);
insert_async_fn(&mut map, "sub", sub);

    Você não precisa usar cloneno final. Tudo o que você precisa fazer é soltar o cadeado antes de retornar.

    drop(map_lock);
map

    Você não precisa do Arc. Arcpode ser usado para garantir que um valor permaneça ativo em vários threads, mas staticjá garante isso.

    No código que você postou, você também não precisa RwLock, mas pode ser necessário se você estiver modificando o mapa após a construção.

    Se estiver usando a versão estável mais recente do Rust, você pode usar LazyLocka biblioteca padrão. Funciona da mesma forma que o de once_cell.

    Geralmente, você não precisa que os erros sejam Sync, mas geralmente precisa que os futuros sejam Send, para que possam ser gerados em tempos de execução multithread.

    Isso nos deixa com isto:

    static MAPS: LazyLock<RwLock<HashMap<&'static str, CalcFn>>> = LazyLock::new(|| {
    let mut map = HashMap::new();

    insert_async_fn(&mut map, "add", add);
    insert_async_fn(&mut map, "sub", sub);

    RwLock::new(map)
});

fn insert_async_fn<K, F, Fut>(map: &mut HashMap<K, CalcFn>, name: K, f: F)
where
    K: Eq + Hash,
    F: Fn(i32, i32) -> Fut + Send + Sync + 'static,
    Fut: Future<Output = BoxedResult<i32>> + Send + 'static,
{
    map.insert(name, Box::new(move |a, b| Box::pin(f(a, b))));
}

    Parque infantil ferrugem

    • 3

relate perguntas