Java

1. Java Programmiersprachenkonzepte Universität HH, SS 2004 29.04.2004 Kai Meyer & Torsten Witte

2. Inhalt • Ursprünge & Anwendungsgebiete • Funktionsweise von Java • Datentypen, Operatoren, Kontrollfluss • Vererbung, Polymorphie • Threads • RMI • Jini • JavaSpace

3. Ursprünge von Java • 23. Mai 1995 Vorstellung von Java durch Sun • Der Name stammt von einer in Amerika üblichen Bezeichnung für Kaffee • Einfache und kompakte, Objekt-orientierte und plattformunabhängige Programmiersprache für Unix-Workstations, PCs und Apple, sowie Micro-Computer in Haushalts- oder Industriegeräten • Java ist für alle Computersysteme (im Allgemeinen kostenlos) verfügbar • Für kommerzielle Anwendungen muss man für die Compiler-Software eine kostenpflichtige Lizenz erwerben

4. Anwendungsgebiete • Ursprünglich: • Steuerung von Haushaltsgeräten und PDAs • Heute: • Datenbanken • Betriebssysteme • Internet • Web-Browser • Unterhaltungselektronik • Handys • Haushaltsgeräte (Toaster, Mikrowelle, Kaffeemaschine, Waschmaschinen, Videorekorder) • Autos • Verkehrsampeln • Kreditkarten • TV-Settop-Boxes für "intelligente" Fernsehapparate • wissenschaftliche Programmierung • usw.

5. Bytecode und JVM • Abstrakte Definition der Maschine, deren Verhalten von dem jeweiligen ausführenden Rechner simuliert wird • Java-Compiler erzeugt plattformunabhängigen Bytecode • Der Bytecode kann auf jedem anderen Computersystem durch die Java Virtual Machine (JVM) ausgeführt werden

6. Elementare Typen • Ganzzahlige Typen: byte 8 Bits (byte)42 -128 bis 127 short 16 Bits (short)42 -32.768 bis 32.767 int 32 Bits 42 -2.147.483.648 bis 2.147.483.647 long 64 Bits 42L -9.223.372.036.854.775.808 bis 9.233.372.036.854.775.807 • Dezimaltypen: float 32 Bits 42.0F -3.4*1038 bis 3.4*1038 double 64 Bits 42.0 -1.8*10308 bis 1.8*10308 • Zeichentyp: char 16 Bits ‘A‘ Zeichen und Symbole • Logischer Typ: boolean true true, false

7. Operatoren • Zuweisung: = Zuweisung • Vergleichsoperatoren für Zahlen und Zeichen: == ist gleich equals ist gleich (bei Objekten) != ist ungleich < ist kleiner als > ist größer als <= ist kleiner oder gleich >= ist größer oder gleich • Logische Operatoren: && und || oder ! nicht

8. Kontrollfluss (1) • Bedingte Verzweigung: if (Bedingung) {Anweisung1; Anweisung2; ...} else {Anweisung1; Anweisung2; ...} switch (variable) { case wert_1: Anweisung1; break; case wert_2: Anweisung2; break; ... default: Defaultanweisung; break; }

9. Kontrollfluss (2) • Schleifen: for (Initialisierung; Ausdruck; Aktualisierung) {Anweisung1; Anweisung2;...} Beispiel: for (int i=0; i<10; i++) { System.out.println(i); } while (Bedingung) // solange noch Bedingung {Anweisung1; Anweisung2;...} do // solange bis Bedingung {Anweisung1; Anweisung2;...} while (Bedingung)

10. Vererbung • (Unter-)Klassen können Operationen von anderen (Ober-)Klassen • implementieren (falls dies nicht in der Oberklasse geschehen ist), • redefinieren (verdecken, überschreiben), • erben, oder • neue Operationen hinzufügen • In Java ist nur Einfachvererbung zwischen Klassen möglich: Oberklasse: Unterklassen:

11. Polymorphie • Objekte einer Unterklasse können an Bezeichner gebunden werden, die mit dem Typ der Oberklasse deklariert sind • Dies kann durch Zuweisung oder durch Parameterübergabe geschehen • Beispiel: public class Oberklasse {...} public class Unterklasse extends Oberklasse {...} public class KlasseX { public void setY(Oberklassey) {...} } Unterklasse _unterklassenbezeichner = new Unterklasse(); Oberklasse _oberklassenbezeichner; _oberklassenbezeichner = _unterklassenbezeichner; // Zuweisung KlasseX _x = new KlasseX(); _x.setY(_unterklassenbezeichner); // Parameterübergabe

12. Threads • Java unterstützt die nebenläufige Programmierung direkt • Das Konzept beruht auf so genannten Threads (zu Deutsch »Faden« oder »Ausführungsstrang«), das sind parallel ablaufende Aktivitäten, die sehr schnell in der Umschaltung sind • Threads können vom Scheduler sehr viel schneller umgeschaltet werden als Prozesse, sodass wenig Laufzeitverlust entsteht • Threads werden entweder direkt von dem Betriebssystem unterstützt oder von der virtuellen Maschine simuliert • Die Integration in die Sprache macht das Entwerfen nebenläufiger Anwendungen in Java einfacher • Java realisiert gegenseitigen Ausschluss von Methoden verschiedenerThreads, Methoden gleicher Threads schließen sich nicht aus

13. Implementation von ThreadsVariante 1 • Threads über die Schnittestelle Runnable implementieren: Z.B. zwei Threads, wobei einer zwanzigmal das aktuelle Datum und die Uhrzeit ausgibt und der andere einfach eine Zahl. class DateThread implements Runnable { public void run() { for ( int i=0; i<20; i++ ) System.out.println( new Date() ); } } class CounterThread implements Runnable { public void run() { for ( int i=0; i<20; i++ ) { System.out.println( i ); } } }

14. Implementation von ThreadsVariante 1 • Direkter Aufruf von run()Sequenzielle Ausführung des Codes • Parallele Ausführung: 1.) Erzeugung eines Thread-Objekts 2.) Aufruf von start() public class FirstThread { public static void main( String args[] ) { Thread t1 = new Thread( new DateThread() ); t1.start();Thread t2 = new Thread( new CounterThread() ); t2.start();} } • Nachdem start() für den Thread eine Ablaufumgebung geschaffen hat, ruft es dann selbstständig die Methode run() genau einmal auf. Läuft der Thread schon, so wirft die start()-Methode eine IllegalThreadStateException

15. Implementation von ThreadsVariante 2 • Die Klasse Thread erweitern: Beispiel: class DateThreadExtends extends Thread { public void run() { for ( int i=0; i<20; i++ ) System.out.println( new Date() ); } } Der Thread startet wieder beim Aufruf vonstart(): Thread t = new DateThreadExtends(); t.start(); Oder auch ohne Zwischenspeicherung der Objektreferenz: new DateThreadExtends().start();

16. Gegenüberstellung der beiden Implementationen

17. Threads beenden Allgemein ist ein Thread beendet, wenn eine der folgenden Bedingungen zutrifft: • Die run()-Methode wurde ohne Fehler beendet. Wenn wir eine Endlosschleife programmieren, würde diese dann potenziell einen nie endenden Thread bilden. • In der run()-Methode tritt eine Exception auf, die die Methode beendet. • Der Thread wurde von außen abgebrochen. Dazu dient die prinzipbedingt problematische Methode stop(), von deren Verwendung abgeraten wird und die auch veraltet ist. Besser, z.B. wenn Thread eine Endlosschleife enthält: Mit der Methode interrupt() von außen in einem Thread-Objekt ein internes Flag setzen, welches dann in der Endlosschleife (in der run()-Methode) durch isInterrupted() periodisch abgefragt wird und falls diese true liefert mit break die Schleife verlassen und so den Thread ohne Fehler terminieren lassen

18. Zustände von Threads • feststellbare Zustände: - nicht erzeugt - laufend (vom Scheduler berücksichtigt) - nicht laufend (vom Scheduler nicht berücksichtigt) - wartend - beendet

19. Lebenszyklus von Java-Threads

20. Synchron oder Asynchron ? • Nebenläufige Threads arbeiten asynchron • Man kann jedoch mit der Methode join() auf das Ende der Aktivität eines Threads warten • Beispiel: class JoinTheThread{ static class JoinerThread extends Thread { public int result; public void run() { result = 1; } } public static void main( String args[] ) throws Exception { JoinerThread t = new JoinerThread(); t.start(); t.join(); // hier wird gewartet bis t fertig ist System.out.println( t.result ); }}

21. Synchronisation mit „synchronized“ • Problem: mehrere Threads wollen (gleichzeitig) auf gemeinsamen Daten schreiben • Folge: inkonsistente Daten • Lösung: zusammenhängende Programmblöcke, die nicht unterbrochen werden dürfen (kritische Abschnitte + gegenseitigen Ausschluss), ABER: Gefahr von Verklemmungen! • Beispiel: Ein Zähler der von mehreren Threads heraufgezählt wird: public class Counter { static int counter = 0; private static Counter _counter=null; private Counter() {} public static Counter getInstance() { if (_counter==null) {_counter = new Counter();} return _counter; } public int get_counter() { return counter; } public synchronized void inc_counter() { counter++; <- ist nicht atomar!!! } }

22. Synchronisation über Warten und Benachrichtigen public class Fernseher { public Fernseher() {} public boolean is_sport() {...} } public class Frau extends Thread { public void run() { synchronized(_fernseher) { _fernseher.wait(); // Sportschau fängt an! } } } public class Mann extends Thread { public void run() { synchronized(_fernseher) { while (!_fernseher.is_sport()) {} _fernseher.notify(); } } }

23. Class java.lang.Thread(Methoden) (1) • void start() ein neuer Thread, neben dem die Methode aufrufenden Thread, wird gestartet. Der neue Thread führt die run()-Methode nebenläufig aus. • void run() diese Methode enthält den parallel auszuführenden Programmcode • boolean isAlive() liefert true, wenn der Thread gestartet und noch nicht terminiert ist • void sleep(long millis, int nanos) der aktuell ausgeführte Thread wird mindestens millis Millisekunden und zusätzlich nanos Nanosekunden eingeschläfert. • void yield() zwingt den aktuell ausgeführten Thread zu pausieren und erlaubt die Weiterführung anderer Threads • void wait() der aktuelle Thread wartet an dem aufrufenden Objekt darauf, dass er nach einem notify() weiterarbeiten kann • void notify() weckt einen beliebigen Thread auf, der an diesem Objekt wartet • void notifyAll() weckt alle Threads auf, die an diesem Objekt warten • void join() der aktuell ausgeführte Thread wartet auf den Thread, für den die Methode aufgerufen wird, bis dieser beendet ist • void interrupt() setzt in einem (anderen) Thread-Objekt ein Flag, um den Thread zu beenden • boolean isInterrupted() fragt das Flag ab • boolean interrupted() testet das entsprechende Flag des aktuell laufenden Threads, und modifiziert es auch, sodass es danach gelöscht ist

24. Class java.lang.Thread(Methoden) (2) Seit JDK 1.2 verworfen und als „deprecated“ eingestuft: • void suspend() blockiert den Thread • void resume() de-blockiert den Thread • void stop() beendet den Thread

25. Remote Method Invocation (RMI) • RMI ist für Java der Mechanismus, um entfernte Objekte und dessen Angebote zu nutzen • RMI (Java) steht im Gegensatz zu dem komplexen CORBA (unterschiedliche Programmiersprachen) • Anpassung von RMI an den defacto Standard CORBA • Somit lässt sich auch über RMI eine Verbindung zwischen Java-Programmen und nicht Java-Programmen herstellen.

26. CORBA • CORBA steht für Common Object Request Broker Architecture • Entwickelt von der Object Management Group (OMG) • Beruht in seinen Grundzügen auf der vom Remote Procedure Call bekannten Technik • Standardisierung von Object Request Broker (ORB) • ORB ist die Basiskomponente der Kommunikation in verteilten Anwendungen. Er dient dazu, Client/Server-Beziehungen zwischen Objekten aufzubauen. • CORBA verfügbar u.a. in C, C++, Java, COBOL, Smalltalk, Ada, Lisp, Python.

27. Vergleich zwischen CORBA und RMI • Viele Ähnlichkeiten in Architektur und Prinzip zwischen RMI und CORBA • Beide bieten Mechaniken wie Garbage Collection, Interface Beschreibung und Naming Service • RMI wurde speziell für Java zugeschnitten, daher Anschein eines abgespeckten CORBAs

28. Vor- und Nachteile • Vorteile zu CORBA • Transparenz • einfache Programmierung • eingebunden in JAVA JDK • URL basierte Namensgebung • Nachteile zu CORBA • auf JAVA beschränkt, d.h. nicht so mächtig • proprietäres Protokoll • Geschwindigkeitsnachteil • wenige Services implementiert (auch nicht vorgesehen) • proprietärer Weg im Gegensatz zu standardisierten CORBA

29. Funktionsweise von RMI • Der Server stellt das entfernte Objekt mit der Funktion bereit. Die Funktion läuft im eigenen Adressraum, und der Server leitet Anfragen an diese Funktion weiter. • Eine Schnittstelle spezifiziert die von den entfernten Objekten bereitgestellten Methoden. • Die Methoden der Schnittstelle müssen dann implementiert werden. • Der RMI-Compiler „rmic“ von Java generiert die Stubs und Skeletons. • Über den Namendienst (Registry) melden die Server ihre entfernten Objekte mit einem Namen an. • Der Client holt sich über die Registry das Objekt mit der gewünschten Methode.

30. Die Schnittstelle import java.rmi.*; public interface Adder extends Remote {public int add(int x, int y) throws RemoteException; } • Übergabe von primitiven Parametern unproblematisch • Übergabe von serialisierbaren Objekten unproblematisch, falls Klassen beiden Seiten bekannt sind, sonst müssen diese Klassen über den RMI-Klassenlader nachgeladen werden.

31. Die Implementation import java.rmi.*;import java.rmi.server.*;public class AdderImpl extends UnicastRemoteObject implements Adder{ public AdderImpl() throws RemoteException { } public int add( int x, int y ) throws RemoteException { return x + y; }}

32. RMIC

33. Stubs und Skeletons (1) • Stubs ist der Stellvertreter für den Server auf der Client-Seite • Skeletons ist der Stellvertreters des Clients auf der Server-Seite • Sind die Objekte die wirklich die Kommunikation betreiben

34. Stubs und Skeletons (2) • 1. Schicht: Kommunikationspartner für Client und Server • 2. Schicht: Regelt die korrekte Ausführung der Operationen • 3. Schicht: Regelt die Netzkommunikation • 4. Schicht: (Internet-)Verbindungsprotokolle

35. Der Server import java.net.*; import java.rmi.*; import java.rmi.server.*; import java.rmi.registry.*; public class AdderServer { public static void main( String args[] ) throws Exception { AdderImpl adder = new AdderImpl();Naming.rebind( "Adder", adder ); System.out.println( "Adder bound" ); } }

36. Der Client import java.rmi.*; import java.rmi.registry.*; import java.rmi.server.*; public class AdderClient {public static void main( String args[] ) { try { Adder a=(Adder)Naming.lookup("Adder"); int sum = a.add( 2, 2 ); System.out.println( sum ); } catch (Exception e) {System.out.println( e );} } }

37. RMI-Methoden • protected UnicastRemoteObject()Erzeugt und exportiert ein neues UnicastRemoteObject und bindet es an einen unbekannten Port. • static RemoteStub exportObject( Remote obj )Exportiert das entfernte Objekt und macht es empfänglich für einkommende Aufrufe. Es wird ein willkürlicher Port verwendet. • static void bind( String name, Remote obj ) Bindet den Stub, an den Namen name und trägt es so in der Registrierung ein. • static void rebind( String name, Remote obj )Wie bind(), nur dass Objekte ersetzt werden, falls sie schon angemeldet sind. • static void unbind( String name )Entfernt das Objekt aus der Registrierung. • static Remote lookup( String name )Liefert eine Referenz auf den Stub, der mit dem entfernten Objekt name verbunden ist. • static String[] list( String name )Liefert ein Feld mit angemeldeten Diensten. Der angegebene Name gibt die URL des Namensdienstes an.

38. Jini Java Intelligence Network Infrastructure • Offiziell wurde Jini am 25. Januar 1999 von Sun Microsystems vorgestellt • Erweiterung der Java-Plattform (Java 2) • Netzwerktechnologie, die es ermöglicht, • Ressourcen im Netzwerk dynamisch zu verwalten • Auffinden von Diensten zu regeln • Geräte untereinander zu verknüpfen • Hauptmerkmale von Jini: • Plattform-Unabhängigkeit • nur Dienste (Services) • keine Unterscheidung zwischen Hard- und Software • Jini kann selbst Basis für weitere Netzdienste (wie JavaSpaces) sein • Infrastruktur: drahtgebunden oder drahtlos • Kommunikation: beliebiges Protokoll, standardmässig: RMI • Jini erweitert die Idee hinter RMI so, dass ein Ort zur Verfügung gestellt wird, an dem die Objekte ihre Services anbieten oder andere Services finden können

39. Funktionsweise von Jini • In einem Jini-Netzwerk gibt es drei verschiedene Gruppen: • Dienst, • Client, • Lookup-Service • Ein Service muss sich im Lookup Service registrieren • Ein Client sucht einen Service (Dienst) über den Lookup Service • Beide müssen allerdings zuerst den Lookup Service finden. Das geschieht über das Discovery.

40. Grundkonzepte von Jini • Discovery: das Finden von Communities im Netz und deren Verbindung untereinander (als spontane Community-Bildung) • Lookup: diese Rolle des Directoryservices in der Jini-Community ist das Suchen und Finden von Diensten unter Berücksichtigung der Typenhierarchie und Vererbungsrelation • Leasing: dieses Konzept impliziert die sogenannte Selbstheilungsfähigkeit im Jini und bedeutet, daß nach einem möglichen Ausfall von Diensten das Recover gesteuert wird und das Wachstum nicht benötigter Dienste in Grenzen gehalten wird (vgl. Garbage Collection) • Remote Events: das bedeutet, daß die Dienste einander Mitteilungen über ihre Statusänderungen machen können (jede Jini-Komponente kann im Prinzip alle (anderen) Events empfangen) • Transactions: hierbei geht es um die sichere Realisierung von Transaktionen, die eine verteilte Ausführung letztendlich erfordert

41. JavaSpaces (1) • JavaSpaces basiert auf der Jini-Technologie (spezieller Jini-Service) • Entstanden aus den „Tuple-Spaces“ von „Linda“ • Ein Space ist ein fortdauerndes Objekt-Lager, das von verschiedenen Prozessen gemeinsam genutzt wird und über das Netzwerk zugänglich ist • Prozesse kooperieren, indem Objekte (Entrys) Spaces betreten und wieder verlassen • Dadurch nur schwach mit einander verbundene Prozesse • Jegliche Kommunikation, sowie die - besonders bei verteilten Systemen - schwierige Synchronisation der Aktivitäten geschieht mit Hilfe des Space

42. JavaSpaces (2) • Die Prozesse führen drei einfache Operationen aus: • write: Objekte in den Space schreiben • read / readIfExists : Objekte, die sich im Space befinden, lesen • take / takeIfExists: Objekte aus dem Space herausnehmen

43. Das „Hello World“ - Beispiel import net.jini.core.lease.Lease; import net.jini.space.JavaSpace; public class HelloWorld { public static void main(String[] args) { try { Message msg = new Message(); msg.content = "Hello World"; JavaSpace space = SpaceAccessor.getSpace(); space.write(msg, null, Lease.FOREVER); Message template = new Message(); Message result = (Message)space.read(template, null, Long.MAX_VALUE); System.out.println(result.content); } catch (Exception e) {e.printStackTrace();} } }

44. Quellen • Vorlesungen P2 / P3 • Galileo- Openbook: http://www.galileocomputing.de/openbook/javainsel/ • Java-API: http://java.sun.com Weitere Quellen: • http://www.heise.de/ix/artikel/1998/11/166/ • http://www.thomasgraf.net/rmi/rmi2.htm • u.a.

45. Fragen ?