{"id":6837,"date":"2015-12-26T07:38:55","date_gmt":"2015-12-26T06:38:55","guid":{"rendered":"https:\/\/www.herr-rau.de\/wordpress\/?p=6837"},"modified":"2023-05-30T11:23:53","modified_gmt":"2023-05-30T09:23:53","slug":"threads-i-allgemeines-und-erstes-java","status":"publish","type":"post","link":"https:\/\/www.herr-rau.de\/wordpress\/2015\/12\/threads-i-allgemeines-und-erstes-java.htm","title":{"rendered":"Threads I – Allgemeines und erstes Java"},"content":{"rendered":"
(5 Kommentare.<\/a>)<\/small> <\/div>\n

Paralleles Arbeiten und die Gr\u00fcnde daf\u00fcr<\/h3>\n\n\n\n

Fr\u00fcher, als ich angefangen habe, war das noch einfach: Da hatte ein Computer einen<\/em> Prozessor: So hei\u00dft das Ding, das das eigentliche Rechenarbeiten \u00fcbernimmt, irgendwo tief drinnen im Computer. Un ein<\/em> Prozessor hei\u00dft, dass eine<\/em> Rechen- oder sonstige Aufgabe gleichzeitig bearbeitet werden kann. Und doch sah es auch fr\u00fcher so aus, als k\u00f6nnte der Computer zwei Sachen gleichzeitig machen: ein Lied abspielen und<\/em> gleichzeitig im Textverarbeitungsprogramm die getippten Zeichen einf\u00fcgen. Vom Laden und Speichern und der Mausbewegung gar nicht zu reden.<\/p>\n\n\n\n

Das funktioniert so, dass der Prozessor zwischen den verschiedenen Programmen sehr schnell wechselt: Ein paar Dutzend Millisekunden darf das Musikspielprogramm ran, dann wieder die Textverarbeitung, dann wieder das Musikprogramm, und so weiter. So entsteht der Eindruck, dass diese Prozesse gleichzeitig ablaufen.<\/p>\n\n\n\n

Bei meinem aktuellen Windows laufen zur Zeit um die sechzig solcher Prozesse ab. Der Taskmanager gibt einem einen \u00dcberblick dar\u00fcber:<\/p>\n\n\n\n

\"threads_prozesse\"<\/figure>\n\n\n\n

Inzwischen haben Computer aber mehr als nur einen Prozessor. Neue kommen mit vier oder acht Prozessoren, und jeder Prozessor kann gleichzeitig und unabh\u00e4ngig von den anderen arbeiten. (Es gibt auch Mischformen, bei denen Prozessoren nur halbwegs unabh\u00e4ngig von einander arbeiten, oder dem Betriebssystem vormachen, es g\u00e4be mehr von ihnen, als eigentlich da sind. Und au\u00dferdem hat inzwischen jede Grafikkarte eigene Prozessoren.)<\/p>\n\n\n\n

Das ist gut so. Denn richtig viel schneller werden die Prozessoren seit einigen Jahren nicht mehr. Wenn man die Illusion hat, dass Computer trotzdem schneller werden, dann liegt es daran, dass die Prozessorzahl erh\u00f6ht wird und deshalb mehrere Dinge gleichzeitig erledigt werden k\u00f6nnen.<\/p>\n\n\n\n

Aber selbst wenn man 32 Prozessoren hat, und eine regul\u00e4re Rechenaufgabe rechnen will – etwa das Berechnen der Fakult\u00e4t von 200 000 – dann dauert das noch ziemlich lange, weil sich trotzdem nur ein Prozessor um diese Rechenaufgabe k\u00fcmmert. Wie viele es sonst noch gibt, ist dann auch egal. (Gut, abgesehen davon, dass generell nicht so viel zwischen Prozessen umgeschaltet werden muss, wenn sie sich auf mehr Prozessoren verteilen k\u00f6nnen.)<\/p>\n\n\n\n

Wenn man m\u00f6chte, dass es richtig<\/em> schnell geht mit dem Rechnen, dann muss man die Rechenaufgabe geschickt verteilen auf die zu Verf\u00fcgung stehenden Prozessoren.<\/p>\n\n\n\n

Fakult\u00e4tsberechnung mit mehreren Prozessoren<\/h3>\n\n\n\n

Fakult\u00e4t schreibt man so: n!<\/code>, und das bedeutet n * (n-1) * (n-2) * (n-3) ... * 1<\/code>
Als Beispiel: 12! = 12*11*10*9*8*7*6*5*4*3*2*1 = 479 001 600<\/code><\/p>\n\n\n\n

Es gibt keine Abk\u00fcrzung oder Formel f\u00fcr das Berechnen der Fakult\u00e4t: Wenn ich 200000! ausrechnen m\u00f6chte, muss ich wirklich all diese Multiplikationen durchf\u00fchren. Das wird schnell sehr aufwendig.<\/p>\n\n\n\n

Wenn ich zwei Prozessoren habe, kann ich die Arbeit aber auf beide verteilen. Um 12! zu berechnen, rechnet der eine dann<\/p>\n\n\n\n

2*4*6*8*10*12<\/code><\/pre>\n\n\n\n
und der andere rechnet<\/p>\n\n\n\n
1*3*5*7*9*11<\/code><\/pre>\n\n\n\n
und am Schluss werden die Ergebnisse multipliziert.<\/p>\n\n\n\n
Ich kann das auch auf vier Prozessoren verteilen:<\/p>\n\n\n\n
1*5*9
2*6*10
3*7*11
4*8*12<\/code><\/pre>\n\n\n\n
Oder sechs:<\/p>\n\n\n\n
1*7
2*8
3*9
4*10
5*11
6*12<\/code><\/pre>\n\n\n\n
Dann geht das Rechnen insgesamt schneller, weil ich alle vorhandenen Prozessoren dazu nutze. Auf meinem Rechner dauert da berechnen von 200000! – eine ziemlich gro\u00dfe Zahl – ohne Verteilung auf mehrere Rechenstr\u00e4nge 76 Sekunden, mit vier Rechenstr\u00e4ngen 12 1\/2 Sekunden, mit acht Str\u00e4ngen gut 10 Sekunden. (Aber nat\u00fcrlich laufen parallel noch viele weitere Prozesse auf meinem Rechner<\/p>\n\n\n\n
Prozesse und Threads<\/h3>\n\n\n\n
Wenn auf einem Rechner mit einem<\/em> Prozessor vier<\/em> Programme laufen, dann muss immer wieder zwischen diesen vier Programmen umgeschaltet werden. Das ist aufwendig. Libre Office ist so ein Programm, Firefox ist so ein Programm, iTunes ist so ein Programm. Die laufen im Moment bei mir alle, wenn auch wahrscheinlich auf unterschiedlichen Prozessoren. Das sind sogenannte schwergewichtige Prozesse.<\/p>\n\n\n\n
Und dann gibt es sogenannte leichtgewichtige Prozesse, die hei\u00dfen auch: Threads. Ein Programm (wie Firefox) l\u00e4sst gleichzeitig viele Threads laufen. Das Umschalten zwischen Threads ist nicht so aufwendig wie das zwischen schwergewichtigen Prozessen: Die geh\u00f6ren ja alle zum gleichen Programm und benutzen den gleichen Arbeitsspeicherbereich f\u00fcr ihre Daten, so dass dieser Bereich dann beibehalten werden kann. (Libre Office und Firefox dagegen nutzen keinen gemeinsamen Arbeitsspeicherbereich, da hat jeder seinen eigenen. Das hei\u00dft, dass beim Umschalten jeweils auch der ganze Arbeitsspeicherbereich ausgetauscht werden muss.)<\/p>\n\n\n\n
Bei dem Firefox-Prozess l\u00e4uft zum Beispiel jeder einzelne Tab als Thread. Das hat einen Nachteil: Wenn ein Thread fehlerhaft ist (wenn ein Tab mit einer Seite Probleme hat und h\u00e4ngen bleibt), muss der ganze Prozess abgebrochen werden – der ganze Firefox h\u00e4ngt und muss neugestartet werden. Bei Chrome dagegen l\u00e4uft jeder Tab als eigener Prozess: Wenn der dann h\u00e4ngt, muss dieser Prozess abgebrochen werden, aber die anderen Prozesse (Tabs) bleiben unbesch\u00e4digt.<\/p>\n\n\n\n
Zust\u00e4nde eines Threads (f\u00fcr den Anfang)<\/h3>\n\n\n\n
\"Threads_1\"<\/figure>\n\n\n\n
Wenn ich in einem Programm einen Thread anlege, befindet der sich erstmal im Zustand NEW. Sobald ich ihm dann sage, dass er loslegen soll, befindet er sich im Zustand RUNNABLE: er k\u00f6nnte laufen, wenn er Rechenzeit auf einem Prozessor kriegt. Ob und wann er wirklich zum Rechnen kommt, darauf hat er keinen Einfluss. Das Betriebssystem entscheidet, wer als n\u00e4chster darf. Dazu greift es nach der einen oder anderen Strategie einen rechenbereiten Thread aus dem Pool aller RUNNABLE Threads heraus und l\u00e4sst ihn ein wenig rechnen: Dann ist der Thread im Zustand RUNNING. Und wenn das Betriebssystem nach der einen oder anderen Strategie entscheidet, dass jetzt aber wieder genug ist, dann landet der Thread im Zustand RUNNABLE und wartet, bis er wieder mal dran kommt. Wahrscheinlich ist er irgendwann fertig mit seiner Aufgabe, dann ist sein Zustand TERMINATED.<\/p>\n\n\n\n
Die Begriffe orientieren sich in diesem Fall an der Sprache Java; in anderen Umgebungen hei\u00dfen die Zust\u00e4nde vielleicht anders.<\/p>\n\n\n\n
Wie ein Thread in Java angelegt wird<\/h3>\n\n\n\n
Das geht sehr einfach. Java bringt bereits eine Klasse Thread<\/code> mit, die die wichtigsten Methoden zur Verf\u00fcgung stellt. Man schreibt sich jetzt einfach selber eine Klasse, die von Thread erbt.<\/p>\n\n\n\n
\"Threads_Toilettenbenutzer\"<\/figure>\n\n\n\n
Das einzige, das unsere neue Klasse tun muss ist: die ererbte run-Methode \u00fcberschreiben. Dann sieht die Klasse zum Beispiel so aus:<\/p>\n\n\n\n
public class Toilettenbenutzer extends Thread {\n  public void run() {\n    System.out.println(getName()+\" benutzt die Toilette.\");\n  }\n}<\/code><\/pre>\n\n\n\n
Damit haben wir eine Klasse f\u00fcr jemanden, der einmal aufs Klo geht. Das ist aber langweilig. Also nehmen wir eine Klasse f\u00fcr jemanden, der immer wieder aufs Klo geht:<\/p>\n\n\n\n
public class Toilettenbenutzer extends Thread {\n  public void run() {\n    while (true) {\n      System.out.println(getName()+\" benutzt die Toilette.\");\n    }\n  }\n}<\/code><\/pre>\n\n\n\n
Oder von mir aus auch 20 mal:<\/p>\n\n\n\n
public class Toilettenbenutzer extends Thread {\n  int anzahl = 0;\n  public void run() {\n    while (anzahl < 20) {\n      System.out.println(getName()+\" benutzt die Toilette.\");\n      anzahl = anzahl + 1;\n    }\n  }\n}<\/code><\/pre>\n\n\n\n
Die Methode getName<\/code> hat unser Toilettenbenutzer<\/code> von der Klasse Thread<\/code> geerbt. Wenn wir den vorgegebenen Namen \u00e4ndern wollen, k\u00f6nnen wir das mit setName(String)<\/code> tun.<\/p>\n\n\n\n
Eine letzte Erg\u00e4nzung: Damit das mit dem Toilettengehen nicht gar so schnell geht, schicken wir unseren Thread jedesmal f\u00fcr zuf\u00e4llige 0.5 bis 1.5 Sekunden schlafen:<\/p>\n\n\n\n
public class Toilettenbenutzer extends Thread {\n  int anzahl = 0;\n  public void run() {\n    while (anzahl < 20) {\n      System.out.println(getName()+\" benutzt die Toilette.\");\n      anzahl = anzahl + 1;\n      try {\n        sleep( (int) Math.random()*1000+500 );\n      } catch (Exception e) { System.out.println(e); }\n    }\n  }\n}<\/code><\/pre>\n\n\n\n
Neu ist eigentlich nur Zeile 8, aber Java m\u00f6chte, dass diese ererbte Thread-Methode nur innerhalb eines try-catch-Blockes aufgerufen wird, das macht es etwas un\u00fcbersichtlicher.<\/p>\n\n\n\n
Ein h\u00e4ufiger Fehler ist es, wenn man jetzt die eben liebevoll angelegte run<\/code>-Methode aufruft. Die wird dann zwar tats\u00e4chlich ausgef\u00fchrt, aber nicht als Thread, sondern regul\u00e4r, also nicht parallel zu anderen Arbeiten. Vielmehr muss man die start<\/code>-Methode der Oberklasse Thread<\/em> aufrufen, und die wiederum ruft die neue run<\/code>-Methode auf – jetzt aber als Thread.<\/p>\n\n\n\n
Jedenfalls haben wir jetzt einen weiteren Zustand von Threads, den des freiwilligen Schlafens:<\/p>\n\n\n\n
\"Threads_3\"<\/figure>\n\n\n\n
Zur Wiederholung: Ruft man die Start-Methode auf, wird der Thread in den Zustand RUNNABLE versetzt, und im Zustand RUNNING wird nach und nach die run-Methode ausgef\u00fchrt (mit Unterbrechungen), bis die run-Methode an ihrem Ende angekommen ist und der Thread im Zustand TERMINATED angekommen ist.<\/p>\n\n\n\n
Jetzt kann man beliebig viele Objekte vom Typ Toilettenbenutzer erzeugen und starten, und alle gehen unabh\u00e4ngig voneinander immer wieder auf die Toilette.<\/p>\n\n\n\n
Damit wir diese Objekte nicht immer wieder von Hand anlegen m\u00fcssen, legen wir eine Starter-Klasse an:<\/p>\n\n\n\n
public class Starter {\n\n  Toilettenbenutzer t0;\n  Toilettenbenutzer t1;\n  Toilettenbenutzer t2;\n  Toilettenbenutzer t3;\n\n  public Starter() {\n    t0 = new Toilettenbenutzer();\n    t1 = new Toilettenbenutzer();\n    t2 = new Toilettenbenutzer();\n    t3 = new Toilettenbenutzer();\n  }\n\n  void starten() {\n    t0.start();\n    t1.start();\n    t2.start();\n    t3.start();\n  }\n}<\/code><\/pre>\n\n\n\n
Und wenn man das dann aufruft, kommt zum Beispiel das heraus:<\/p>\n\n\n\n
Thread-3 benutzt die Toilette.\nThread-2 benutzt die Toilette.\nThread-1 benutzt die Toilette.\nThread-4 benutzt die Toilette.\nThread-4 benutzt die Toilette.\nThread-3 benutzt die Toilette.\nThread-1 benutzt die Toilette.\nThread-2 benutzt die Toilette.<\/code><\/pre>\n\n\n\n
Schwierig wird es nur, wenn alle dieselbe Toilette benutzen sollen, und das m\u00f6glichst nicht gleichzeitig, sondern nacheinander…<\/p>\n\n\n\n
(Fortsetzung folgt.<\/a> Und bitte gerne auf fachliche Fehler hinweisen.)<\/p>\n\n\n\n
Aufgaben:<\/strong><\/p>\n\n\n\n