Início / coding / Perguntas / 77165392
Accepted
David Thielen
Asked: 2023-09-24 08:39:47 +0800 CST

Como posso atualizar uma lista em cache onde outros threads retêm a lista de cache antiga

  • 772

Eu tenho uma lista de usuários em cache no meu aplicativo. Algumas páginas de administração precisam da lista de todos os usuários (o total é pequeno o suficiente, isso não é um problema).

A abordagem que estou adotando é:

  1. Quando a lista em cache for solicitada, essa lista não será alterada.
  2. Quando um usuário é CrUD, há uma chamada para adicioná-lo ao cache.
  3. Quando essa chamada é feita, a lista existente é copiada para a nova lista e o usuário CrUD é adicionado/atualizado/removido da lista. E essa lista é então a nova lista em cache.

Boa ideia. Mas acabei de escrever alguns testes de unidade que fazem isso e não funcionam. Porque 2 threads estão reconstruindo a lista e aquele que a escreve em segundo lugar vence. Posso fazer uma lock (this)reconstrução da lista e isso funciona muito bem.

Mas essa é uma abordagem terrível. Ótimo para identificar o problema, mas não é bom na produção.

Em uso normal, essa abordagem de qualquer lista retornada é imutável e funciona muito bem. Como posso fazer isso sem um lock?

Em C#, mas esta é uma questão independente de linguagem, embora possa haver alguma classe C#, etc., que torna esta uma solução fácil.

c#

1 respostas

  1. Best Answer

    Como posso fazer isso sem um lock?

    Você não pode. Pelo menos não se você quiser usar um List<T>que contenha objetos mutáveis User. A List<T>coleção não é segura para threads. Mesmo que fosse, a mutação dos Userelementos que ele contém sem sincronização resultaria em um comportamento com erros/indefinido.

    Posso fazer uma lock (this)reconstrução da lista e isso funciona muito bem. Mas essa é uma abordagem terrível.

    Não necessariamente. Se você fizer uso cuidadoso da lockdeclaração, o que significa que você protege apenas a interação com o estado compartilhado (a lista e os usuários) e não a reconstrução da nova lista antes que ela seja compartilhada, a contenção provavelmente será mínima e o desempenho bastante decente.

    É claro que existem outras opções disponíveis, que não envolvem um arquivo List<T>. Por exemplo:

    1. ConcurrentDictionary<K,V>atualizado com GetOrAdd/ AddOrUpdate.
    2. ImmutableList<T>atualizado com ImmutableInterlocked.Update.

    Ambas as alternativas de bloqueio baixo exigem que o Usertipo seja imutável. Eles não apenas terão um desempenho melhor (provavelmente), mas também serão mais convenientes.

    Exemplo com a ConcurrentDictionary<K,V>e record classas User:

    // Record classes are immutable by default
public record class User(int Id, string Name, int Reputation);

private readonly ConcurrentDictionary<int, User> _users = new();

// Add a new user with 10 reputation,
// or increment the reputation of an existing user by 10.
public User ReputationIncrement(int id, string userName)
{
    return _users.AddOrUpdate(id,
        key => new User(key, userName, 10),
        (key, existing) => existing with { Reputation = existing.Reputation + 10 });
}

    Demonstração on-line .

    • 0

relate perguntas