C ++ thread-safe Mapa

Question

Alguém sabe onde eu posso encontrar um implimentation que envolve um std::map e torna o segmento de seguros? Quando digo enfiar I meio seguro que oferece apenas acesso serial ao mapa, um segmento em um tempo. Idealmente, este mapa deve utilizar apenas a biblioteca padrão e / ou impulsionar as construções.

Answer 1

Não preenche os critérios que você especificou, mas você pode ter um olhar para os TBB recipientes. Não é assim chamado concurrent_hash_map que permite que múltiplos threads acessem simultaneamente os dados no mapa. Existem alguns detalhes, mas tudo está muito bem documentado e pode lhe dar uma idéia do "container concorrente". Dependendo de suas necessidades isso pode ser totalmente inapropriada ...

Answer 2

Não é geralmente uma boa idéia para as classes de coleta para fornecer fios de segurança, porque eles não podem saber como eles estão sendo usados. Você será muito melhor servido através da implementação de suas próprias mechainisms bloqueio nas construções de nível superior que utilizam as coleções.

Answer 3

O impulso shared_mutex iria fornecer a melhor abordagem escritor leitor / única múltipla para embalar um mapa padrão dadas suas limitações. Eu não sei de qualquer implementações "pré-construídos" que se casam com estes dois desde que a tarefa é geralmente trivial.

Answer 4

Este é até a aplicação de implementar. Um mapa "thread-safe" iria fazer chamadas individuais para o thread-safe mapa, mas muitas operações precisam ser feitas thread-safe através chamadas. O aplicativo que usa o mapa deve associar um mutex com o mapa, e usar essa exclusão mútua para coordenar acessos a ele.

Tentando fazer recipientes thread-safe foi um erro em Java, e seria um erro em C ++.

Answer 5

Você pode olhar para segmento seguro Template Library

Answer 6

Tente esta biblioteca

http://www.codeproject.com/KB/threads/lwsync.aspx

Ele é implementado em um c ++ actual abordagem baseada em políticas.

Aqui está algum corte a partir do link para mostrar a idéia com o caso 'vetor'

typedef lwsync::critical_resource<std::vector<int> > sync_vector_t;
sync_vector_t vec;

// some thread:
{
   // Critical resource can be naturally used with STL containers.
   sync_vector_t::const_accessor vec_access = vec.const_access();
   for(std::vector<int>::const_iterator where = vec_access->begin();
         where != vec_access->end();
         ++where;
        )
   std::cout << *where << std::endl;
}

sync_vector_t::accessor some_vector_action()
{
   sync_vector_t::accessor vec_access = vec.access();
   vec_access->push_back(10);
   return vec_access;
   // Access is escalated from within a some_vector_action() scope
   // So that one can make some other action with vector before it becomes
   // unlocked.
}

{
   sync_vector_t::accessor vec_access = some_vector_action();
   vec_access->push_back(20);
   // Elements 10 and 20 will be placed in vector sequentially.
   // Any other action with vector cannot be processed between those two
   // push_back's.
}

Answer 7

Eu vim com isso (que eu tenho certeza que pode ser melhorado para ter mais de dois argumentos):

template<class T1, class T2>
class combine : public T1, public T2
{
public:

    /// We always need a virtual destructor.
    virtual ~combine() { }
};

Isso permite que você faça:

// Combine an std::mutex and std::map<std::string, std::string> into
// a single instance.
combine<std::mutex, std::map<std::string, std::string>> lockableMap;

// Lock the map within scope to modify the map in a thread-safe way.
{
    // Lock the map.
    std::lock_guard<std::mutex> locked(lockableMap);

    // Modify the map.
    lockableMap["Person 1"] = "Jack";
    lockableMap["Person 2"] = "Jill";
}

Se você quiser usar um std :: recursive_mutex e um std :: set, que também funcionaria.

Answer 8

Não é uma proposição aqui (por mim - plug descarado) que envolve objetos (incluindo recipientes STL) para eficiente (custo zero) Tópico acesso seguro:

https://github.com/isocpp/CppCoreGuidelines/issues/924

A idéia básica é muito simples. Existem apenas algumas classes de moldagem usado para impor ler / de bloqueio de escrita e, ao mesmo tempo, apresentando quer uma const (para leitura apenas) ou não-const (para leitura e escrita) vista do objecto envolvido.

A idéia é torná-lo em tempo de compilação impossível aceder indevidamente um recurso compartilhado entre threads.

código de implementação pode ser encontrada aqui:

https://github.com/galik/GSL / blob / bloqueáveis-objetos / include / gsl / gsl_lockable