Allgemeine Informationen
In diesem Buch, das im Teubner-Verlag erschienen ist,
wird das parallele Java-Hamster-Modell ausführlich erläutert.
Autor:
Dr.-Ing. Dietrich Boles, Universität Oldenburg
Bibliographische Angaben:
Erscheinungsjahr: Juni 2008
Seitenanzahl: 452
Preis: 34,90 EUR
ISBN: 978-3-8351-0229-3
Werbetext:
Das Buch behandelt die wesentlichen Konzepte der parallelen Programmierung, d. h. der Entwicklung nebenläufiger Systeme.
Es orientiert sich dabei am Thread-Konzept der Programmiersprache Java.
Als didaktische Hilfsmittel werden anschauliche und spielerische Elemente des so genannten Hamster-Modells eingesetzt.
Programmierer entwickeln Programme, in denen selbstständige Hamster - die Prozesse -
bei Aufgaben wie der Erkundung ihres Lebensraumes oder bei der gemeinsamen Suche nach Körnern kooperieren,
konkurrieren, miteinander kommunizieren und sich untereinander synchronisieren müssen.
Zielgruppe:
Studierende der Informatik an Fachhochschulen und Universitäten,
Studierende anderer Fachrichtungen mit Informatik als Nebenfach,
Praktiker in der Industrie
Ziele und Motivation (aus dem Vorwort):
Ursprüngliches Ziel des Hamster-Modells war es, Programmieranfängern die "Angst" vor der
Programmierung zu nehmen und die Komplexität der vielen technischen, methodischen und inhaltlichen Neuigkeiten,
die anfangs auf sie einströmen, zu reduzieren.
Nahezu alle Bücher zum Erlernen der Programmierung beginnen mit Typen, Operatoren, Ausdrücken und Variablen.
Durch die Nähe dieser Konstrukte zur Mathematik werden davon bereits viele Schüler bzw. Studienanfänger
abgeschreckt. Im Hamster-Modell beginnen Programmieranfänger mit den wesentlichen Konzepten der
(imperativen) Programmierung, nämlich den Anweisungen. Das Programmieren verläuft damit quasi analog zu
Tätigkeiten des alltäglichen Lebens, wie Kochen, Basteln oder Puzzlen. Im Mittelpunkt steht hierbei der Begriff
des Algorithmus und damit das Wesentliche der Programmierung, nämlich das Lösen von Problemen mit
Hilfe des Computers.
Der größte Vorteil des Hamster-Modells - in Zusammenhang mit dem Hamster-Simulator, einer Software
zum Entwickeln und Ausführen von Hamster-Programmen - ist, dass Anweisungen bzw. Befehle, die man dem Computer erteilt,
direkt visualisiert werden. Beim Befehl vor hüpft bspw. ein Hamster im Territorium eine Kachel nach vorne.
Programmieranfänger können damit unmittelbar nachvollziehen, was ihre Programme tun und ob sie korrekt oder fehlerhaft sind.
Diese Visualisierung motiviert Programmieranfänger deutlich mehr als mittels System.out.println Zahlenkolonnen
auf die Konsole zu schreiben.
Dass in den spielerischen Elementen des Hamster-Modells und der Visualisierung von Anweisungen noch deutlich mehr
Potential steckt, als Programmieranfängern das Erlernen der grundlegenden Programmierkonzepte zu erleichtern,
demonstriert dieses Buch.
Sie als Leser wollen die parallele Programmierung kennenlernen. Sie wollen wissen, was sich hinter dem Thread-Konzept
von Java verbirgt. Genau das werden Ihnen in diesem Buch die Hamster demonstrieren.
Die Hamster werden nämlich als visuelle Repräsentation von Prozessen bzw. Threads genutzt; das
Thread-Konzept von Java wird durch die Hamster quasi visualisiert.
Vielleicht werden Sie jetzt sagen "Ich bin
doch gar kein Kind mehr. Ist das nicht alles ein bisschen kindisch mit den Hamstern!?"
Ich bin mir ziemlich sicher, dass Sie das bereits nach den ersten Kapiteln
anders sehen werden. Es macht einfach deutlich mehr Spaß, beim Ausführen eines selbst entwickelten
Programms den Hamstern bei ihrer Arbeit zuzuschauen, als wie in anderen Lehrbüchern zur parallelen
Programmierung Textausgaben der Threads auf der Konsole mühsam nachvollziehen zu müssen.
Sie sehen an den Aktionen der Hamster unmittelbar, was Ihr Programm tut und ob es das tut,
was es soll, oder noch Fehler enthält.
Ein paar Beispiele sollen Ihnen schon einmal Geschmack auf das machen, was Sie in diesem
Buch erwartet:
- Hamster sind selbstständige Prozesse, die sich Wettrennen liefern: "Wer erreicht als erster
das leckere Korn?"
- Die Hamster bekommen die Aufgabe, Körnerhaufen der Größe nach zu sortieren. Gemeinsam geht das viel schneller.
- Die Hamster wollen gemeinsam erkunden, auf welcher Kachel des Territoriums die
meisten Körner liegen. Dazu müssen sie miteinander kommunizieren.
- Die Hamster wissen, dass auf der anderen Seite einer tiefen Schlucht besonderes leckere Körner
liegen. Leider führt jedoch nur eine schmale, instabile Brücke über die Schlucht, die immer nur abwechselnd
betreten werden darf. Um nicht in die Schlucht zu stürzen, müssen die Hamster das Betreten der Brücke
untereinander koordinieren.
- Die Hamster wollen einen gefährlichen Berg erklimmen. Einer von Ihnen ist jedoch noch ein ziemlich
unerfahrener Bergsteiger. Die anderen müssen ihm helfen.
- Die Hamster simulieren das bekannteste Problem der parallelen Programmierung, das so genannte
Philosophen-Problem. Gelingt es ihnen, die Benutzung einer eingeschränkten Menge von Gabeln zu synchronisieren,
um nicht Gefahr zu laufen, elendig verhungern zu müssen?
Inhaltverzeichnis
Vorwort
1. Einleitung
2. Das Hamster-Modell
3. Selbstständige Hamster
4. Threads
5. Scheduling
6. Kommunikation zwischen Threads
7. Mehrseitige Synchronisation
8. Einseitige Synchronisation
9. Verklemmungen
10. Beendigung von Threads
11. Klassische Probleme der parallelen Programmierung
12. Sperren
13. Zugabe
Anhang
Glossar
Literaturverzeichnis
Index
Aus der Einleitung:
Das vorliegende Buch ist so aufgebaut, dass nach dieser motivierenden Einleitung in Kapitel 2 das Hamster-Modell vorgestellt
wird. Hamster sind Objekte einer vordefinierten Klasse Hamster, auf deren Methoden in Kapitel 2 im Detail eingegangen wird.
Objekte im objektorientierten Sinn können als passiv angesehen werden. Der Programmierer bestimmt, wann für welches
Objekt welche Methode aufgerufen wird. Da aber die Klasse Hamster von der Java-Klasse Thread
abgeleitet ist, kann man die Hamster mit Hilfe des Thread-Konzepts aus dieser Lethargie befreien:
Die Hamster werden selbstständig. Was sich genau hinter dem Begriff der Selbstständigkeit
verbirgt und wie man als Programmierer mit selbstständigen Hamstern umgeht, das demonstriert Kapitel 3.
Während Kapitel 3 eher einen motivierenden und einführenden Überblick über das Thread-Konzept von Java gibt, widmet sich
Kapitel 4 anschließend ausführlich der Klasse Thread, die im Mittelpunkt der Thread-Programmierung mit
Java steht. Das Kapitel zeigt insbesondere, wie man Threads definieren, erzeugen und starten kann. Weiterhin erörtert
das Kapitel den Nutzen und die Einsatzbereiche von Threads.
Beim Thread-Konzept von Java haben wir es mit einer Quasi-Parallelität zu tun. Der Java-Scheduler kümmert sich
darum, welcher Thread wann und wie lange den Prozessor zugeteilt bekommt. Kapitel 5 stellt den Java-Scheduler vor
und zeigt, wie man das Scheduling als Programmierer beeinflussen kann.
Ab Kapitel 6 wird das Sozialleben der selbstständigen Hamster erweitert. Während sie bis hierhin eigentlich recht
isoliert und jeder für sich gearbeitet haben, werden sie in Kapitel 6 mit der Fähigkeit ausgestattet, miteinander
zu kommunizieren, d.h. Informationen auszutauschen. Die Kommunikation zwischen Threads basiert dabei auf
der Verwendung gemeinsamer Variablen. In Kapitel 6 werden verschiedene Varianten der Nutzung gemeinsamer Variablen
zur Kommunikation zwischen Threads aufgezeigt.
Der Zugriff mehrerer Threads auf gemeinsame Variablen kann zu schwerwiegenden Fehlern führen, insofern er nicht
synchronisiert wird. Die Hamster demonstrieren derartige Programmierfehler in Kapitel 7 auf eindrucksvolle Weise. Sie stellen
in diesem Kapitel mit dem synchronized-Konstrukt jedoch auch
das Konzept vor, das Java zur Vermeidung von Synchronisationsfehlern zur Verfügung stellt.
Das Warten eines Threads auf einen anderen ist eine spezielle als einseitige Synchronisation bezeichnete
Form der Synchronisation, die in Kapitel 8 behandelt wird.
Genau genommen wird bei der einseitigen Synchronisation nicht auf einen anderen Thread gewartet, sondern auf die
Erfüllung einer Bedingung durch einen anderen Thread. Wenn jedoch zwei Threads darauf warten, dass jeweils der
andere eine bestimmte Bedingung erfüllt, kommt es zum dauerhaften Stillstand des Programms, Verklemmung
genannt. Mit bestimmten Typen derartiger
Verklemmungen, wie Deadlocks und Livelocks, setzt sich Kapitel 9 auseinander.
So traurig es auch klingt, in Kapitel 10 müssen wir uns mit dem Tod der Hamster beschäftigen. Genauer
geht es in diesem Kapitel um die Frage, ob und wie man Threads stoppen bzw. beenden kann.
Mit Kapitel 10 sind die Basiskonzepte der Thread-Programmierung mit Java vollständig eingeführt.
Mit Kapitel 11 folgt ein Kapitel, das den Einsatz der Konzepte bei der Lösung etwas komplexerer Probleme
demonstriert. Genauer werden in diesem Kapitel die drei großen Probleme der parallelen Programmierung,
das Leser-Schreiber-Problem, das Erzeuger-Verbraucher-Problem und das Philosophen-Problem, in die
Hamster-Welt übertragen und durch die Hamster gelöst und visualisiert.
Über die Basiskonzepte hinaus stellt Java weitere fortgeschrittene Programmierkonzepte zum Umgang mit Threads zur Verfügung,
auf die in den Kapiteln 12 und 13 eingegangen wird. Kapitel 12 stellt mit Semaphoren und expliziten
Sperren Alternativen zur Synchronisation vor, die flexibler als das
in Kapitel 7 eingeführte synchronized-Konstrukt einsetzbar sind.
In Kapitel 13 demonstrieren die Hamster die Verwendung einiger sehr nützlicher Thread-Mechanismen, die
insbesondere zur Koordination mehrerer Threads vorteilhaft genutzt werden können.
Abgerundet wird das vorliegende Buch mit einem Anhang, in dem noch einmal alle Java-Klassen zum
Umgang mit Threads sowie die vordefinierten Klassen des Java-Hamster-Modells zusammengefasst werden.
Ein Glossar erläutert kurz und knapp die wichtigsten Begriffe der parallelen Programmierung
und der Programmierung mit Java-Threads. Das Literaturverzeichnis gibt einen Überblick über
referenzierte und weiterführende Bücher. Und zu guter Letzt erlaubt ein Sachverzeichnis das schnelle
Auffinden bestimmter Begriffe im Text.
Online-Bestellung bei Amazon:
Materialien
- alle Beispielprogramme des Buches:
bsp-band3.zip (ca. 480 KBytes)
