Embed Size (px)
Citation preview
Java
ProgrammiersprachenkonzepteUniversität HH, SS 2004
29.04.2004
Kai Meyer & Torsten Witte
Inhalt
• Ursprünge & Anwendungsgebiete• Funktionsweise von Java• Datentypen, Operatoren, Kontrollfluss• Vererbung, Polymorphie• Threads• RMI• Jini• JavaSpace
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
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.
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
Elementare Typen• Ganzzahlige Typen:
byte 8 Bits (byte)42 -128 bis 127short 16 Bits (short)42 -32.768 bis 32.767int 32 Bits 42 -2.147.483.648 bis 2.147.483.647long 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
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
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;
}
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)
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:
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(Oberklasse y) {...}}
Unterklasse _unterklassenbezeichner = new Unterklasse();Oberklasse _oberklassenbezeichner;_oberklassenbezeichner = _unterklassenbezeichner; // Zuweisung
KlasseX _x = new KlasseX();_x.setY(_unterklassenbezeichner); // Parameterübergabe
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 verschiedener Threads, Methoden gleicher Threads schließen sich nicht aus
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 ); }
}}
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
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 von start():Thread t = new DateThreadExtends();t.start();
Oder auch ohne Zwischenspeicherung der Objektreferenz:new DateThreadExtends().start();
Gegenüberstellung der beiden Implementationen
Vorteil Nachteil
Ableiten von Thread (extends Thread)
Programmcode in run() kann die Methoden der Klasse Thread nutzen
Da es in Java keine Mehrfachvererbung gibt, kann die Klasse nur Thread erweitern
Implementieren von Runnable(implements Runnable)
Die Klasse kann von einer anderen, problemspezifischen Klasse erben
Kann sich nur mit Umwegen selbst starten; allgemein: Thread-Methoden können nur über Umwege genutzt werden
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
Zustände von Threads
• feststellbare Zustände:- nicht erzeugt- laufend (vom Scheduler berücksichtigt)- nicht laufend (vom Scheduler nicht berücksichtigt)- wartend- beendet
Lebenszyklus von Java-Threads
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 );}}
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!!!}}
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();} }
}
Class java.lang.Thread (Methoden) (1)
• void start() ein neuer Thread, neben dem die Methode aufrufenden Thread, wirdgestartet. 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
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
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.
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.
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
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
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.
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.
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;}
}
RMIC
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
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
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" );
}}
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 );}}
}
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.
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
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.
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
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
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
Das „Hello World“ - Beispielimport 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();}
}}
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.
Fragen ?
