Multithreading

[marykillsjane]

if (!hThread || !dwThreadID)
return 1;
Wofür ist dieser if Befehl?
if hThread nicht und dwThreadID nicht wiederhole
Ich verstehe nicht was diese anweisung bezwecken soll und außerdem wäre es noch nett wenn mir jmd erklären könnte warum hier bei return eine 1 gesetzt wird kenne es bis jetzt nur mit einer 0 ?

Originally Posted by .SkyneT.

Falls dein Compiler C++0x unterstützt könntest du Threads so verwenden:

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

    void ThreadFunc() 
    {
        std::this_thread::sleep(std::chrono::seconds(1)); 
    }

    int main() 
    {
        std::thread Thread(ThreadFunc); //Start Thread

        Thread.join(); //Wait untill the thread finishes its work
        return 0;
    }

Ich denke er wird erstweil auch ohne auskommen.

Es scheint als würde der Visual c++ 2010 Compiler kein C++0x
unterstützen da er mir etliche Fehler anzeigt und es sich auch nicht Compilen lässt trd danke für die Antwort.

[Nightblizard]

Originally Posted by marykillsjane

if (!hThread || !dwThreadID)
return 1;
Wofür ist dieser if Befehl?
if hThread nicht und dwThreadID nicht wiederhole
Ich verstehe nicht was diese anweisung bezwecken soll und außerdem wäre es noch nett wenn mir jmd erklären könnte warum hier bei return eine 1 gesetzt wird kenne es bis jetzt nur mit einer 0 ?

Das if macht folgendes:

if(hThread == 0 || dwThreadID == 0)

Und etwas anderes als 0 gibt man dann zurück, wenn das Programm frühzeitig bzw. unerwartet beendet wird. Also konkret wenn ein Fehler aufgetreten ist. Aber das ist nur wichtig, wenn externe Programme prüfen sollen, ob dein Programm sauber beendet wurde.

Originally Posted by marykillsjane

Es scheint als würde der Visual c++ 2010 Compiler kein C++0x
unterstützen da er mir etliche Fehler anzeigt und es sich auch nicht Compilen lässt trd danke für die Antwort.

Warum nutzt du nicht die aktuelle 2012er Version? Da wird das bereits unterstützt.

[MrSm!th]

2012 hat afaik noch ein paar Bugs. Ist das nicht sogar noch in der Beta?

[Nightblizard]

Ich nutz das seit es noch VS11 Beta hieß und kann mir nicht mehr vorstellen wieder zurück zu müssen. Intellisense ist deutlich zuverlässiger (aber noch immer ziemlich beschissen), vom C++11 Standard ist deutlich mehr implementiert und du hast jede Menge andere neue Spielzeuge bekommen wie z.B. C++ AMP.

Bugs sind mir bisher keine aufgefallen, abgesehen von den üblichen Intellisense Spinnereien.

Das wurde vor ein oder zwei Wochen erst auf den Markt gebracht, also keine Beta, nein.


Ein Updgrade von Visual Studio hat sich imo bisher noch immer gelohnt und das ist dieses mal nicht anders!

[marykillsjane]

Originally Posted by Nightblizard

Das if macht folgendes:

if(hThread == 0 || dwThreadID == 0)

Und etwas anderes als 0 gibt man dann zurück, wenn das Programm frühzeitig bzw. unerwartet beendet wird. Also konkret wenn ein Fehler aufgetreten ist. Aber das ist nur wichtig, wenn externe Programme prüfen sollen, ob dein Programm sauber beendet wurde.


Warum nutzt du nicht die aktuelle 2012er Version? Da wird das bereits unterstützt.

Danke für die erklärung.
Ich nutze die 2010er version von Visual c++ ,da es bei einem Buch was ich mir mal gekauft habe als Cd dabei war und ich mich wie gesagt bis jetzt eigentlich wenig-garnicht mit meinem Compiler befasst habe da ich ja erstmal die Grundlegenden Dinge lernen wollte.
Wenn ich mir jetzt die 2012 version holen will kostet das bestimmt wd was oder kann man das kostenlos updaten?Weil wenn es Kostenpflichtig ist lohnt sich sowas für mich wenn überhaupt erst in einigen Monaten wenn ich auch was mit den ganzen neuen Dingen anfangen kann ^^.

Die Fragen haben sich nun auch alle geklärt ich habs jetzt auch endlich gebacken bekommen es nicht durch enter ( wegen getchar() ) die Schleife stoppen zu lassen sondern per eingabe vielen Dank an alle ihr habt echt Hammer Beispiele gebracht und das auch noch sehr schnell.
Gute Community hier ^^.

[Preakz]

/************************************************** *******************/
/************************************************** *******************/
long WINAPI thread1()
{
while (1)
{

}
return 0;
}
/************************************************** *******************/
/************************************************** *******************/
long WINAPI thread2()
{
while (1)
{

}
return 0;
}
/************************************************** *******************/
/************************************************** *******************/
long WINAPI thread3()
{
while (1)
{

}
return 0;
}
/************************************************** *******************/
/************************************************** *******************/
long WINAPI thread4()
{
while (1)
{

}
return 0;
}
/************************************************** *******************/
/************************************************** *******************/
int main()
{

HANDLE hThread1 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)thread1, 0, 0, 0);
HANDLE hThread2 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)thread2, 0, 0, 0);
HANDLE hThread3 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)thread3, 0, 0, 0);
HANDLE hThread4 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)thread4, 0, 0, 0);

WaitForSingleObject(hThread1, INFINITE);
WaitForSingleObject(hThread2, INFINITE);
WaitForSingleObject(hThread3, INFINITE);
WaitForSingleObject(hThread4, INFINITE);



CloseHandle(hThread1);
CloseHandle(hThread2);
CloseHandle(hThread3);
CloseHandle(hThread4);

return 0;


}
/************************************************** *******************/
/************************************************** *******************/

[MrSm!th]

Wenn ich mir jetzt die 2012 version holen will kostet das bestimmt wd was oder kann man das kostenlos updaten?Weil wenn es Kostenpflichtig ist lohnt sich sowas für mich wenn überhaupt erst in einigen Monaten wenn ich auch was mit den ganzen neuen Dingen anfangen kann ^^.

Es gibt immer auch die kostenlose Express Version.

[daemon7777]

@Preakz

Also ich würde nicht 4 Funktionen erstellen, die genau das Gleiche machen. Damit verfehlst du ja irgendwie den Sinn von Funktionen. Ich bevorzuge da eher so etwas:

void WINAPI thread_func(LPVOID param)
{
  std::cout << "Hello from Thread "<<(int)param<<endl;
}

int main()
{
  HANDLE hThread1 = CreateThread(NULL, 0,  (LPTHREAD_START_ROUTINE)thread_func, (void *)0, 0, 0);
HANDLE hThread2 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)thread_func, (void *)1, 0, 0);
HANDLE hThread3 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)thread_func, (void *)2, 0, 0);
HANDLE hThread4 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)thread_func, (void *)3, 0, 0);

WaitForSingleObject(hThread1, INFINITE);
WaitForSingleObject(hThread2, INFINITE);
WaitForSingleObject(hThread3, INFINITE);
WaitForSingleObject(hThread4, INFINITE);



CloseHandle(hThread1);
CloseHandle(hThread2);
CloseHandle(hThread3);
CloseHandle(hThread4);

return 0;


}

Ich habe nochmal eine andere Frage, die bei mir aufgetaucht ist. Wie schaut es denn eigentlich bei parallelen Algorithmen mit dem Zugriff auf Speicherplatz aus?
Wenn wir zB einen MergeSort hernehmen: können die 4 Threads gleichzeitig auf verschiedene Stellen eines int-Arrays zugreifen? Die Speicherstellen würden sich ja nie überschneiden. Also müsste das ja (meiner Meinung nach) eigentlich gehen.
Aber wie sähe das jetzt zB bei einem Vector (der hierfür denke ich eh nicht geeignet ist) aus?

[MrSm!th]

Sollte mit beiden eigentlich problemlos gehen

[tnd0]

Bei Vectoren ist es nur bedingt möglich - man kann nicht vorhersagen wann und ob bei einer Vectoroperation neuer Speicher angefordert wird und somit der gesamte Vector im Speicher verlagert wird. Bei einer Sortierfunktion kommt es auf den Vector an - bei einem Vector der nur Pointer enthält ist es von den Zugriffen her durchaus möglich, denn ein Pointer ist von atomarer größe, wird also immer im gesamten gelesen und geschrieben, sodass keine kaputten Pointer gelesen werden können da entweder der gesamte Pointer geändert wurde oder noch nichts.

An sich stelle ich es mir jedoch schwierig vor einen generellen Vector mit mehrere Threads zu sortieren, angenommen der vector sieht so aus:

1
3
2
4

und man hat 2 Threads die den Vector sortieren sollen - der erste Thread muss zwangsläufig die "3" in den unteren Speicherbereich schieben, für den aber eigentlich der 2te Thread zuständig ist. Der zweite Thread tauscht die 2 mit der 3 bevor der erste Thread bei der 3 angekommen ist, hat diese aber eventuell bereits in einer Puffervariable - das Resultat von dem Beispielvector sortiert mit der Bubblesort Methode und 2 Threads ergibt nach der Sortierung dadurch wieder den Ausgangsvector. Bei nicht atomaren Werten wie char* ggf. einen Deadlock oder eine AV.

[MrSm!th]

Er sagte ja auch nicht Bubblesort, sondern Mergesort: Das ist auf Verfahren ultithreading ausgelegt, hab jetzt aber auch nicht im Kopf, wie es funktioniert.

man kann nicht vorhersagen wann und ob bei einer Vectoroperation neuer Speicher angefordert wird

Wieso sollte beim reinen verschieben von bereits vorhandenen und allozierten Elementen neuer Speicher angefordert werden?
Lässt sich da der Standard echt so viel Spielraum? oO