C ++ Thema Sichere Karte

Question

Weiß jemand, wo ich eine implimentation finden, die eine std::map wickelt und macht es sicher eingefädelt? Wenn ich Thread-sicher sagen, meine ich, dass es nur seriellen Zugriff auf die Karte bietet, einen Thread zu einem Zeitpunkt. Im Optimalfall sollte diese Karte verwenden Sie nur die Standard-Bibliothek und / oder Konstrukte steigern.

Answer 1

Ist die Kriterien nicht erfüllen, die Sie festgelegt haben, aber man konnte einen Blick auf die TBB Container haben. Es gibt so genannte concurrent_hash_map, die mehrere Threads ermöglicht gleichzeitig die Daten in der Karte zuzugreifen. Es gibt einige Details, aber alles ist gut dokumentiert und Sie können eine Vorstellung von der „Concurrent Container“ geben. Je nach Bedarf kann dies völlig ungeeignet sein ...

Answer 2

Es ist in der Regel keine gute Idee für die Sammlung Klassen Thread-Sicherheit zur Verfügung zu stellen, weil sie nicht wissen können, wie sie verwendet werden. Sie werden viel besser durch die Umsetzung Ihrer eigenen Verriegelungs mechainisms in den höheren Ebene Konstrukte, die die Sammlungen verwenden bedient werden.

Answer 3

Der Boost shared_mutex würde den besten mehr Leser / Schreiber Einzel Ansatz eine Standard-Karte gegeben, um Ihre Einschränkungen wickeln. Ich weiß nicht von irgendwelchen „vorgefertigten“ Implementierungen, die diese beiden heiraten, da die Aufgabe der Regel trivial ist.

Answer 4

Dies ist bis zur Anwendung zu implementieren. Eine „thread-safe“ Karte würde einzelne Anrufe in die Karte Thread-sicher machen, aber viele Operationen müssen Thread-sicher über Anrufe gemacht werden. Die Anwendung, die die Karte verwendet, sollte einen Mutex mit der Karte verbinden, und dass Mutex verwenden Zugriffe auf mich zu koordinieren.

Der Versuch, Thread-sichere Behälter war ein Fehler in Java, und es wäre ein Fehler in C ++.

zu machen

Answer 5

Sie können sehen Sichere Template Library Thema

Answer 6

Versuchen Sie, diese Bibliothek

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

Es ist in einem modernen c ++ richtlinienbasierte Ansatz umgesetzt werden.

Hier ist etwas, geschnitten aus dem Link, um die Idee mit dem ‚Vektor‘ Fall zu zeigen

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

kam ich mit diesem nach oben (was ich bin sicher, verbessert werden kann, mehr als zwei Argumente zu nehmen):

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

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

Auf diese Weise 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 eine std :: recursive_mutex und ein std :: verwenden gesetzt, das würde auch funktionieren.

Answer 8

Es ist ein Satz, hier (von mir - schamlose Werbung), die Objekte Wraps (einschließlich STL Container) für eine effiziente (Zero-Cost) -Thread sicheren Zugang:

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

  

Die Grundidee ist sehr einfach. Es gibt nur wenige Wrapper-Klassen verwendet, um erzwingen Lese- / Schreibverriegelung und, zugleich, präsentiert entweder eine const (für read-only) oder nicht-const (für Read-Write) Ansicht des verpackten Objekts.

     

Die Idee ist, es unmöglich zu machen, Zeit kompiliert unsachgemäß eine Ressource zwischen Threads gemeinsam genutzt werden.

Die Umsetzung Code kann hier gefunden werden:

https://github.com/galik/GSL / Blob / abschließbaren-Objekte / include / GSL / gsl_lockable