#include <Windows.h>
 #include <iostream.h>

unsigned long __stdcall funtion ()
{
for(;;) {
    Sleep(300);
    cout << "thread" << endl;
}
}

 int main(int argc, char *argv[])
 {
DWORD servtId;
HANDLE servThread;
servThread = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)funtion,NULL,0,&servtId);
for(;;) {
    Sleep(300);
cout << "ABC" << endl;
}
system("PAUSE");
     return 1;
 }

So nun zu den Fragen:
1.) In der Console schreibt er mir threadABC oder ABCthread aber ich mach doch jweils mit endl eine neue Zeile, sind das evenutell die nebenwirkungen von den threads.
2.) Ist es Sinnvoll den thread am schluss vom Programm mit ExitThread zu schließen weil wenn man porg gekillt wird ist der Thread ja auch weg!
3.) Habe das so hinbekommen weil ich in der MSDN gelesen habe aber wie mache ich sowas in Linux?

MFG RedUX

1.) In der Console schreibt er mir threadABC oder ABCthread aber ich mach doch jweils mit endl eine neue Zeile, sind das evenutell die nebenwirkungen von den threads.
2.) Ist es Sinnvoll den thread am schluss vom Programm mit ExitThread zu schließen weil wenn man porg gekillt wird ist der Thread ja auch weg!
3.) Habe das so hinbekommen weil ich in der MSDN gelesen habe aber wie mache ich sowas in Linux?

Zu 1): Ja, das sind leider Nebenwirkungen - sollte man bei Threads vermeiden, dazu kannst du dir mal Mutexe anschauen. Bevor du etwas schreibst, guckst du ob der Mutex frei ist bzw wartest darauf, dann "lockst", also blockierst ihn, schreibst deinen Text plus Leerzeile und gibst ihn wieder frei. So wird garantiert, dass nur ein Objekt gleichzeitig etwas machen kann, z.B. schreiben.

Zu 2): Da kommen oft Leute und sagen, ExitThread wäre böse. Inwieweit das stimmt, kann ich kein Stück beurteilen, aber es ist definitiv viel schöner, wenn dein Thread sich selber beendet - durch ein return oder durch das erreichen der letzten Zeile.

Zu 3): Ja, das wüsste ich auch gerne

Badestrand schrieb:

Zu 3): Ja, das wüsste ich auch gerne

Ich hab noch mal ein bisschen gegoogelt und das hier gefunden:
[url]
http://www.risc.uni-linz.ac.at/people/schreine/papers/rt++-linuxmag1/main.html[/url]
Ist zienlich gut erklärt konnte es aber selber nochnicht testen!

Badestrand schrieb:

Zu 1): Ja, das sind leider Nebenwirkungen - sollte man bei Threads vermeiden, dazu kannst du dir mal Mutexe anschauen. Bevor du etwas schreibst, guckst du ob der Mutex frei ist bzw wartest darauf, dann "lockst", also blockierst ihn, schreibst deinen Text plus Leerzeile und gibst ihn wieder frei. So wird garantiert, dass nur ein Objekt gleichzeitig etwas machen kann, z.B. schreiben.

Zum ausgeben brauche ich die Threads nicht, ich brauche sie für einen Clienten der empfangen soll während er Sendet. Dazu brauch ich Mutexe nicht oder?
Schöne Nacht noch.
MFG ReduX

3.) Habe das so hinbekommen weil ich in der MSDN gelesen habe aber wie mache ich sowas in Linux?

Für sowas empfehle ich immer gerne plattformunabhängige Bibliotheken wie die von Boost.

Und dort gibt es auch eine Thread-Library, zu der es von kharchi auch eine ganz nette Einleitung gibt:

http://www.kharchi.de/threads.html

PS: iostream.h ist veraltet
Nutz lieber iostream + using namespace std; oder schreib vor die Funktionen aus iostream std::

The-Kenny schrieb:

PS: iostream.h ist veraltet
Nutz lieber iostream + using namespace std; oder schreib vor die Funktionen aus iostream std::

Ich weiß
War ja nur ein Bsp. Code

MFG ReduX

@2: Threads von außen abzuschießen IST böse - auf die Weise nimmst du ihm die Chance, hinter sich aufzuräumen. Besser ist es, dem Thread von außen zu sagen, daß er jetzt Feierabend machen soll - und dann zu warten, bis er sich beendet hat.
(btw wird dein Hauptprogramm auch endlos weiterlaufen ;))

Wie The-Kenny schon sagte würde auch ich hier auf jeden Fall den Einsatz der boost.thread Library empfehlen. Eine "boost"-Version Deines Programms würde etwa so aussehen.

#include <iostream>
#include <string>
#include <boost/thread/thread.hpp>
#include <boost/bind.hpp>  // Zl.4
#include <Windows.h>        // Sleep

void function( const std::string& txt, int cnt ) // Zl.7
{
    using namespace std;
    for( ; cnt; --cnt )
    {
        Sleep(300);
        cout << txt << endl; // Zl.13
    }
}
int main()
{
    boost::thread thrd( boost::bind( &function, "thread", 20 ) );
    function( "ABC", 20 );
    thrd.join();
    return 0;
}

inklusive sauberen Beenden des Programms.

Wenn Du jetzt vor den Zeilen 4, 7 und 13 noch folgendes einfügst:

#include <boost/thread/mutex.hpp> // 4
boost::mutex io_guard; // 7
        boost::mutex::scoped_lock lock( io_guard ); // 13; hinter Sleep!

so werden die Ausgaben auch nicht mehr vermischt.

Ab boost 1.34 ist die Installation von boost auch wesentlich besser erklärt.

Bem.: dieses Programm sollte so auch unter Linux laufen, wenn man das #include <Windows.h> ersetzt, versteht sich von selbst ...

Gruß
Werner

http://asio.sourceforge.net/boost_asio_0_3_7/libs/asio/doc/tutorial/tuttimer3.html

MFG ReduX

Ich möchte Code::Blocks verwenden.
Kann ich dann trozdem den installer von Boost Consulting nehmen?

Sollte IMHO eigentlich nicht möglich sein (unterschiedliche Compiler => Unterschiedliches Binärformat).

cu André

Aber ganz ehrlich: so schwer ist das nicht! Die Anleitung ist zwar lang, aber da ist viel bla bla mit drin. Und die Eigentliche Arbeit sind nur ein paar Handgriffe. Ich würde es wenigstens nach der Anleitung probieren. Einfach nur probieren...

MFG ReduX

1.) Wenn ich nun Threads einbaue benötige ich später eine .dll von boost, doch der name "boost_thread-mgw34-mt-1_34_1.dll" ist mir zu lang ich würde gerne das die Datei "thread.dll" heißt, wie mache ich das?.
2.) Was bedeutet beim Bsp. Code am schluss das thrd.join(); ? Beendet es den Thread? Oder besser gibt es eine gute Doku für boost?
3.) Was bringt mir boost außer Threads sonst noch, als ich im boost verzeichnis rumgeschaut habe sind mir sachen wie iostreams etc. aufgefallen, dass sind aber sachen die bei C++ stan**** sind!

1. Du kannst bjam beim aufrufen noch ein Parameter mitgeben, dann benennt er die Dateien einfach libboost_.a und boost_.dll.
2. Der Befehl thread.join() wartet so lange, bis der Thread fertig ist.
3. boost.iostreams ist kein Ersatz für die normalen Ein- und Ausgabestreams, eine komplette Doku gibt es hier