Ich möchte einen Verweis auf ein Objekt an einen Thread weitergeben und solange der Thread lebt gelockt lassen, sodass dies nicht an einen anderen Thread vergeben werden kann.

Das hier ist weit entfernt vom Funktionieren, doch es verdeutlich vielleicht meine Pläne etwas besser:

struct DataChunk {
    // shared_array
    // ein mutex?
};

std::shared_ptr <DataChunk> KLASSE::grab() {
    // EDIT:
    boost::lock_guard <boost::mutex> (this->container_access_mutex);
    for (auto i = std::begin(DataChunks); i != std::end(DataChunks); ++i) {
        if (i->LOCK_MEMBER->try_lock()) {
            // return *i;
        }
    }
}

// In einem Thread:
{
    KLASS instanz; // wo auch immer die her kommt
    auto d = instanz.grab();
    boost::lock_guard </* ... */> scoped_lock (d.LOCK_MEMBER);
}

EDIT: Das Problem ist die Threadsafety und der Zugriff auf den mutex von 2 verschiedenen Orten.

Zugriff auf den mutex von 2 verschiedenen Orten.

Was soll daran ein Problem sein? Mutexe selbst sind ein atomic_bool mit drumherum. Die sind völlig Threadsafe, sonst würde ja rein gar nichts funktionieren.

- Wie würdest du / würdet ihr den Mutex weitergeben. (irgendein wrapper wie shared_ptr um den mutex?)
- Kann man sie versehentlich kopieren?
- wenn ich ein lock_guard verwende mit dem bereits gelockten mutex, wie erzeuge ich den guard (defer_lock)?

Ansonsten... falls das relevant sein sollte: ne Mutex darfst du nur aus dem Thread wieder freigeben der sie auch gelockt hat. Wenn du in einem Thread locken willst, dann an einen anderen übergeben und dort dann später unlocken, dann musst du nen binären Semaphor statt ner Mutex nehmen. Bei nem Semaphor ist das nämlich erlaubt.

---------------------------------------------------------------------------------------
Zunächst: Ich habe meine Frage falsch und schlecht gestellt.
---------------------------------------------------------------------------------------

Ich habe mir einen Puffer erdacht, in den ich gleichzeitig lesen und schreiben kann mit mindestens einem Lesethread und mindestens einem Schreibthread.
Der Puffer besteht aus einer Queue mit shared_array Instanzen (="chunk").
Durch "grab_w" wird ein Chunk erstellt (bis zu einem maximum) und gibt ihn zurück, damit er mit Daten gefüllt werden kann.
Die Funktion "grab_r" gibt ein Chunk zurück, der nicht mehr außerhalb verwendet wird (von einem grab_w aufruf) (in richtiger Reihenfolge, daher queue).
Außerdem wird er aus der queue entfernt.

Ich scheitere gerade an dem wrapper, der ein chunk enthält und automatisch die Klass "DataFeed" mitteilt, dass er nicht mehr verwendet / noch verwendet wird.

Schematische Benutzung von "DataFeed":

Hier mal schnell im Forum geschrieben:

// Beispielhaftes Interface für die Klasse darunter:
class DataFeed {
public:
    class DataChunk {
        // ???
    };
private:
    uint32_t max_queue_size_;
    uint32_t chunk_size_;
    std::queue </* ??? */> queue_;

    void wait_r_avail() const; // verwendet vielleicht std::conditional_variable
    void wait_w_avail() const; // blockiert solange queue_.size() == max_queue_size_

    DataChunk grab_w(); // impl ?
    DataChunk grab_r(); // impl ?
};

// ok der Klassenname ist jetzt doof, aber ich editiere ihn nicht, falls schon jemand angefangen hat den zu zitieren.
class asnyc_rw {
private:
    thread reader_;
    thread writer_;
    DataFeed buffer_;
    std::atomic_long_long remaining_; // remaining data
    uint32_t chunk_size_; // im ctor erhalten und an DataFeed weitergereicht

private:
    void read();
    void write();

public:
    void transfer();

    // mehr (ctor, dtor, ...)
};
//-------------------------------------------------------------------------------------------------------------------
void async_rw::transfer() {
    reader_ = thread(std::bind(&async_rw::read, this));

    write(); // evtl später in thread "writer_"
}
//-------------------------------------------------------------------------------------------------------------------
void async_rw::read() {
    std::ifstream file ("somewhere", std::ios_base::binary);
    do {    
        buffer_.wait_w_avail(); // blockiert solange die queue ihre maximale Größe hat. Sollte zu Beginn niemals blockieren
        auto chunk = buffer_.grab_w(); // hat chunk_size_ größe
        file.read(chunk.get(), chunk_size_); // oder ähnlich
    } while (file.gcount());

    // lese daten von festplatte oder sonstwo her und speicher sie in chunk

    // chunk läuft out of scope und wird damit verfügbar durch die Funktion "buffer_.grab_r"
    // Die blockierende Funktion "buffer_.wait_r_avail()" lässt nun ein Mal durch (zB. std::conditional_variable::notify_one()) und ist danach wieder blockierend
}
//-------------------------------------------------------------------------------------------------------------------
void async_rw::write() {
    while (remaining_.load()) {
        buffer_.wail_r_avail();        // verwendet vielleicht std::conditional_variable
        auto chunk = buffer_.grab_r(); // soll wenn obige Funktion fälschlicherweise nicht verwendet wird geworfen

        // verschicke "chunk" mit socket
    }
}
//-------------------------------------------------------------------------------------------------------------------

std::atomic_bool b;
b.store(true);

std::shared_ptr <std::atomic_bool> spb;
spb->store(true); // BOOOOOMMMM (SIGSEV in "void store(/* ... */) noexcept"

wie gesagt GCC 4.8.1 (mingw)

Was habe ich hier verletzt?

EDIT: haha shred_ptr :D... hammer Tippfehler

Was habe ich hier verletzt?

Dein Pointer zeigt auf kein Objekt.

Tim06TR schrieb:

Was habe ich hier verletzt?

Dein Pointer zeigt auf kein Objekt.

uuuoooopppsss

ok ich geh schlafen *derp*

EDIT: Ich habe nicht die Zeit von vorhin bis jetzt gebraucht, ich habe noch eine andere Codestelle umgebaut.

Zugriff auf den mutex von 2 verschiedenen Orten.

Was soll daran ein Problem sein? Mutexe selbst sind ein atomic_bool mit drumherum. Die sind völlig Threadsafe, sonst würde ja rein gar nichts funktionieren.

Das klingt fast wie:

Ein Betriebssystem ist ein

void main() { }

mit drumherum.