Warten bis Thread fertig

[tanja.hopfer]

Hallo zusammen,

wie kann man allgemein feststellen ob ein Thread fertig mit seiner Bearbeitung ist? Das heisst so lange der Thread noch arbeitet soll eine bestimmte Aktion durchgeführt werden.

Danke,

Tanja

[Sone]

tanja.hopfer schrieb:

Hallo zusammen,

wie kann man allgemein feststellen ob ein Thread fertig mit seiner Bearbeitung ist? Das heisst so lange der Thread noch arbeitet soll eine bestimmte Aktion durchgeführt werden.

Danke,

Tanja

Durch ein Flag?
Aber ich denke, du willst eigentlich eher sowas:

std::thread th { ... };

// bestimmte Aktion

th.join(); // Die Memberfunktion join() wartet, bis der Thread fertig ist.

[Del1nquenz]

std::thread::joinable

[tanja.hopfer]

Danke Sone. Aber wie sagt man ihm denn, dass man ihm dass man so lange er arbeitet eine andere Aktion durchführen will?

[Sone]

tanja.hopfer schrieb:

Danke Sone. Aber wie sagt man ihm denn, dass man ihm dass man so lange er arbeitet eine andere Aktion durchführen will?

Hä?

Soweit ich verstanden habe, hast du folgendes Szenario: Du hast zwei Threads, den Haupthread und einen weiteren, erzeugt durch std::thread o.ä.

Jetzt möchtest du, solange der zweite Thread arbeitet, eine bestimmte Aktion im ersten durchführen. Ist das richtig?

Dann musst du mit Flags arbeiten. Es gibt dann ein Flag, auf das beide zugreifen können. Am Anfang ist das Flag auf true. Dann kommst du bspw. in eine Schleife, in der du eine Aktion durchführst, solange das Flag true ist. Im zweiten Thread wird am Ende, nachdem die Arbeit getan ist, das Flag auf false gesetzt. Anschließend muss im ersten wieder der Thread gejoined werden.

Beispiel:

#include <iostream>
#include <thread>
#include <mutex>
#include <chrono>

int main()
{
    bool flag = true;
    std::mutex flagMutex;

    std::thread th{ [&]
                    {
                        std::this_thread::sleep_for( std::chrono::seconds{5} );
                        std::lock_guard<std::mutex> guard{flagMutex};
                        flag = false;
                    } };

    for(;;)
    {
        std::cout << "Working!" << std::endl;
        std::this_thread::sleep_for( std::chrono::seconds{1} );

        std::lock_guard<std::mutex> guard{flagMutex};
        if( !flag )
            break;
    }

    th.join();
}

Del1nquenz schrieb:

std::thread::joinable

Und was soll sie* damit anfangen? Sobald der Thread gestartet ist, und auch nachdem er beendet ist, kann gejoined werden.

Ist doch eine sie, oder?

[Youka]

Del1nquenz schrieb:

std::thread::joinable

Erst startest du deinen Thread, dann fährst du fort mit deiner anderen Aufgabe, welche in einer Schleife läuft, die durch den Zustand der Inaktivität des Threads abbricht. Del1nquenz hat bereits die Funktion zur Statusabfrage erwähnt.

[tanja.hopfer]

Nein ich habe nur einen Thread nicht zwei, und will nur wissen wann er beendet ist, und so lange er nicht beendet ist soll eine andere Aktion durchgeführt werden.

[SeppJ]

In dem Beispiel ist nur ein zusätzlicher Thread neben dem Hauptthread. Wenn du nur den Hauptthread hättest, dann benutzt du gar keine Threads in dem Sinne, wie man das normalerweise meint.

[knivil]

Nun, das wird ohne weiteres nicht gehen. Dazu brauchst du Kommunikationsmittel wie Signale, Mutex oder atomare Variablen. D.h. am Ende deines Threads wird eine "globale" Variable "fertig" auf wahr gesetzt, die immer abgefragt wird. Das eine Moeglichkeit, einfach aber nicht sehr sauber.

[tanja.hopfer]

@Seppj und alle anderen: Hat man denn keine Möglichkeit abzufragen ob der Thread noch läuft? Wie z.B. while(thread.istnichtfertig) do ... ?

[SeppJ]

Ich würde mir an dieser Stelle gerne wünschen, dass du mal konkret wirst. Ich befürchte nämlich gerade aus Erfahrung, dass du eigentlich was ganz konkretes vor hast, das mit den vielen Standardsynchronisationsmitteln eigentlich ganz einfach wäre, du aber gar nicht weißt, was alles möglich ist und daher kompliziert fragst.

[knivil]

tanja.hopfer schrieb:

@Seppj und alle anderen: Hat man denn keine Möglichkeit abzufragen ob der Thread noch läuft? Wie z.B. while(thread.istnichtfertig) do ... ?

Nein, diese uebergeordnete Logik ist selbst zu implementieren.

[Sone]

knivil schrieb:

tanja.hopfer schrieb:

@Seppj und alle anderen: Hat man denn keine Möglichkeit abzufragen ob der Thread noch läuft? Wie z.B. while(thread.istnichtfertig) do ... ?

Nein, diese uebergeordnete Logik ist selbst zu implementieren.

... wie ich bereits mit einem trivialen Beispiel gezeigt habe.

Youka schrieb:

Del1nquenz schrieb:

std::thread::joinable

Erst startest du deinen Thread, dann fährst du fort mit deiner anderen Aufgabe, welche in einer Schleife läuft, die durch den Zustand der Inaktivität des Threads abbricht. Del1nquenz hat bereits die Funktion zur Statusabfrage erwähnt.

Ja, und die ist hier - zum zweiten mal - unangebracht. Das funktioniert nicht.

N3337 [thread.thread.member]/2 schrieb:

bool joinable() const noexcept;

Returns: get_id() != id()

N3337 [thread.thread.id]/1 schrieb:

Each thread of execution has an associated thread::id object that is not equal to the thread::id object of any other thread of execution
and that is not equal to the thread::id object of any std::thread object that does not represent threads of execution.

joinable() hat nichts mit dem "Arbeitsstatus" des Threads zu tun, sondern damit, ob der Thread bspw. default-constructed wurde.

[Del1nquenz]

Und was soll sie* damit anfangen? Sobald der Thread gestartet ist, und auch nachdem er beendet ist, kann gejoined werden.

Hab mich da wohl vertan.

[Sone]

Del1nquenz schrieb:

Und was soll sie* damit anfangen? Sobald der Thread gestartet ist, und auch nachdem er beendet ist, kann gejoined werden.

Hab mich da wohl vertan.

Ach, absolut kein Problem.
Wenn ich das bloß jedes mal einfach so hätte schreiben können...

[tanja.hopfer]

@SeppJ, ja das glaube ich auch. Also ich habe einen Thread angelegt der etwas ausführen soll im Hintergrund, jedoch so lange er ausgeführt wird eine bestimmte Aktion ausgeführt wird, die anzeigt, dass der thread noch arbeitet.

[Ethon]

Dann mach es so wie Sone dir gezeigt hat?

[Bitte ein Bit]

@tanja.hopfer:
Meinst du so ewtas?

Pseudocode

typedef enum
{
  RUNNING,
  ENDED
} tThreadStatus;

void Thread_Function1(tThreadStatus& Status)
{
  Status = RUNNING;
  // do something
  Status = ENDED;
}

void abc()
{
  tThreadStatus Status;  // Status, welcher unser Thread setzt

  Start_Thread(Thread_Function1, Status)
  while(Status == RUNNING)
  {
    // do something
  }
}

Anmerkung:
Dies ist nur eine Ideen-Skizze und keine Implementierung und hat per Definition nichts mit C++ zu tun. :p

[xStrykex]

Hört sich für mich nach einer Art Statusmeldung/Ladebalken an, der z.B. im Vordergrund laufen soll während im Hintergrund gearbeitet wird.

[Youka]

Statt diesem Gemache mit den Locks, wäre für Windows Threads nicht GetExitCodeThread eine elegante Lösung?