C++ - Thread-Safe-Karte

Weiß jemand, wo ich finden kann ein implimentation, dass wraps eine std::map und macht es thread-sicher? Wenn ich sage, thread-sichere ich meine, dass es bietet nur einen seriellen Zugriff auf die Karte, ein thread zu einem Zeitpunkt. Optimal, diese anzeigen sollten nur die standard-Bibliothek und /oder boost-Konstrukte.

InformationsquelleAutor der Frage Chris Andrews | 2009-05-04

  1. 11

    Erfüllt nicht die Kriterien, die Sie angegeben haben, aber man konnte einen Blick auf die TBB Container. Es gibt so genannte concurrent_hash_map wodurch mehrere threads zugreifen, die gleichzeitig die Daten in der Karte. Es gibt einige details, aber alles ist schön dokumentiert und können Ihnen eine Vorstellung von der "concurrent container". Je nach Ihren Bedürfnissen, könnte dies völlig unangebracht...

    InformationsquelleAutor der Antwort Anonymous

  2. 4

    Ist es in der Regel nicht eine gute Idee für die collection-Klassen bieten, thread-Sicherheit, denn Sie können nicht wissen, wie Sie verwendet werden. Sie wird viel besser gedient werden, durch die Umsetzung Ihrer eigenen sperren mechainisms in der höheren Ebene konstruiert, dass die Nutzung der Sammlungen.

    InformationsquelleAutor der Antwort

  3. 2

    Boost shared_mutex wäre die beste multiple-reader/single-writer-Ansatz für die Verpackung einer standard-Karte gegeben, Ihre Zwänge. Ich kenne keine "pre-built" - Implementierungen, die heiraten diese beiden, da die Aufgabe ist in der Regel trivial.

    InformationsquelleAutor der Antwort Joe

  4. 1

    Dies ist bis zu der Anwendung zu implementieren. Einen "thread-sicheren" Karte machen würde, einzelne Anrufe in der Karte, thread-sichere, aber viele Operationen vorgenommen werden müssen thread-safe über Anrufe. Die Anwendung, die die Karte nutzt, sollte associate ein mutex mit der Karte und verwenden Sie das mutex zu koordinieren, greift darauf zu.

    Versuchen, um thread-sichere Container war ein Fehler in Java, und es wäre ein Fehler in C++.

    InformationsquelleAutor der Antwort Dan Breslau

  5. 1

    Könnte man auf Thread-Sichere Template Library

    InformationsquelleAutor der Antwort Jay

  6. 1

    Versuchen, diese Bibliothek

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

    Umgesetzt wird es in einer modernen c++ - Richtlinien-basierten Ansatz.

    Hier einige Schnitt aus dem link zeigen, die Idee mit dem 'vector' Fall

    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.
}

    InformationsquelleAutor der Antwort Mykola Golubyev

  7. 0

    Ich kam mit dieser (dessen bin ich mir sicher verbessert werden kann, um mehr als zwei Argumente):

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

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

    Das können Sie tun:

    //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";
}

    Wenn Sie möchten, verwenden Sie eine std::recursive_mutex und ein std::set, das würde auch funktionieren.

    InformationsquelleAutor der Antwort Jerry

  8. 0

    Es ist eine Aussage hier (von mir - shameless plug) , umschließt Objekte (einschließlich STL Container) für die effiziente (zero-cost -) thread-safe Zugriff:

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

    Die grundlegende Idee ist sehr einfach. Es sind nur ein paar wrapper-Klassen verwendet, um zu erzwingen, Lesen/schreiben sperren und, zur gleichen Zeit, zu präsentieren, entweder einen const (für read-only) oder non-const (für read-write) Ansicht des eingebundenen Objekts.

    Die Idee ist, um es zu compile-Zeit unmöglich falsch Zugriff auf eine resource von mehreren threads gemeinsam verwendet.

    Code zur Implementierung finden Sie hier:

    https://github.com/galik/GSL/blob/lockable-objects/include/gsl/gsl_lockable

    InformationsquelleAutor der Antwort Galik

Schreibe einen Kommentar