Wie benutze ich rand_r und wie benutze ich es Thread-sicher?

Ich versuche zu lernen, wie zu verwenden, rand_r, und nach der Lektüre diese Frage ich bin immer noch ein wenig verwirrt, kann mir bitte jemand einen Blick darauf werfen und zeigen, was ich bin fehlt? Nach meinem Verständnis, rand_r nimmt einen Zeiger auf einen Wert (oder einen Speicherbereich mit einigen Anfangswert), und Sie verwenden es zur Erzeugung neuer zahlen, jedes mal wenn es aufgerufen wird. Jeder thread, der fordert, rand_r liefern sollte, Sie mit einem eindeutigen Zeiger (oder Speicherbereich), um das "eigentliche " zufällige" zahlen zwischen verschiedenen threads. Deshalb:

int globalSeed;

//thread 1
rand_r(&globalSeed);

//thread 2
rand_r(&globalSeed);

ist der falsche Weg, es zu benutzen. Wenn ich 

int seed1,seed2;

//thread 1
rand_r(&seed1);

//thread 2
rand_r(&seed2);

dies der richtige Weg wäre, um zu generieren "true random" zahlen zwischen threads?

EDIT: zusätzliche Fragen nach der Lektüre Antworten auf die oben genannten Artikel:

  1. wenn in thread 1, ich brauche eine zufällige
    Zahl zwischen 1 bis n soll ich tun
    (rand_r(&seed1) % (n-1)) + 1 ? Oder gibt es andere übliche Weg, dies zu tun?
  2. Ist es richtig oder normal ist, wenn der Speicher für die Samen ist dynamisch zugeteilt?

InformationsquelleAutor der Frage derrdji | 2010-10-19

  1. 15

    Richtig. Was Sie tun, im ersten Fall ist die Umgehung der thread-Sicherheit Natur rand_r. Mit vielen non-thread-safe-Funktionen, persistenten Zustand gespeichert ist, zwischen den aufrufen der Funktion (wie die zufällige Streuung hier).

    Mit der thread-safe-Variante, die Sie tatsächlich einen thread-spezifischen Teil der Daten (seed1 und seed2), um sicherzustellen, der Zustand wird nicht zwischen threads gemeinsam genutzt werden.

    Beachten Sie, dass dies nicht die zahlen wirklich zufällig ist, macht es nur die Sequenzen unabhängig voneinander. Wenn Sie beginnen, Sie mit der gleichen Saat, werden Sie wahrscheinlich erhalten die gleiche Reihenfolge, in beide threads.

    Beispiel, sagen wir, Sie bekommen eine zufällige Reihenfolge 2, 3, 5, 7, 11, 13, 17 aufgrund einer ersten Samen von 0. Mit einem gemeinsamen Samen, abwechselnd die Aufrufe rand_r aus zwei verschiedenen threads führen würde:

    thread 1                thread 2
           <---  2
                 3 --->
           <---  5
                 7 --->
           <--- 11
                13 --->
           <--- 17

    - und das ist die besten Fall - man kann tatsächlich feststellen, dass der gemeinsame Staat beschädigt wird, da die updates auf kann es nicht atomar sind.

    Mit nicht freigegebenen Zustand (mit a und b für die beiden anderen Quellen von Zufallszahlen):

    thread 1                thread 2
           <---  2a
                 2b --->
           <---  3a
                 3b --->
           <---  5a
                 5b --->
                 ::

    Einige thread-sicheren Aufrufe müssen Sie die thread-spezifische Status wie diesen, können andere das erstellen von thread-spezifischen Daten unter der Bettdecke (mit einem thread-ID oder ähnliche Informationen), so dass Sie nie brauchen, um über es, und Sie können genau den gleichen source-code im Gewinde und nicht-Gewinde-Umgebungen. Ich bevorzuge letzteres, mich, einfach, weil es macht mein Leben einfacher.

    Zusätzliche Sachen für die bearbeitete Frage:

    > If in thread 1, I need a random number between 1 to n, should I do '(rand_r(&seed1) % (n-1)) + 1', or there is other common way of doing this?

    Angenommen, Sie wollen einen Wert zwischen 1 und n inclusiveverwenden Sie (rand_r(&seed1) % n) + 1. Das erste bit gibt Sie einen Wert von 0 zu n-1 inclusive, fügen Sie dann 1, um den gewünschten Bereich.

    > Is it right or normal if the memory for the seed is dynamically allocated?

    Den Samen hat, beharrlich zu sein, solange Sie Sie verwenden. Sie könnte dynamisch verteilen es in den thread aber könntest du auch erklären, es in den thread ' s top-level-Funktion. In beiden Fällen müssen Sie, um die Kommunikation der Adresse bis zu den unteren Ebenen irgendwie (es sei denn, dein thread ist nur, dass eine Funktion, die sehr unwahrscheinlich ist).

    Könntest du entweder geht es nach unten durch die Funktion aufruft oder eine Globale array-irgendwie, wo die unteren Ebenen können, entdecken Sie die richtige Saatgut-Adresse.

    Alternativ, da brauchst du ein globales array sowieso haben, können Sie eine Globale Palette von Saatgut statt Saatgut-Adressen, die die unteren Ebenen verwenden könnte, um zu entdecken, Ihren Samen.

    Würden Sie wohl (in beiden Fällen mit dem globalen array) haben eine formschlüssige Struktur mit der thread-ID als Schlüssel und das Saatgut zu verwenden. Man müsste dann schreiben Sie Ihre eigenen rand() - routine, die sich die richtigen Samen und rief rand_r().

    Diese ist der Grund, warum ich bevorzuge die library-Routinen, die dies tun, unter der Decke mit einer thread-spezifischen Daten.

    InformationsquelleAutor der Antwort paxdiablo

Schreibe einen Kommentar