Java
This presentation is the property of its rightful owner.
Sponsored Links
1 / 45

Java PowerPoint PPT Presentation


  • 74 Views
  • Uploaded on
  • Presentation posted in: General

Java. Programmiersprachenkonzepte Universitä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.

Download Presentation

Java

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Java

Java

Programmiersprachenkonzepte

Universität HH, SS 2004

29.04.2004

Kai Meyer & Torsten Witte


Inhalt

Inhalt

  • Ursprünge & Anwendungsgebiete

  • Funktionsweise von Java

  • Datentypen, Operatoren, Kontrollfluss

  • Vererbung, Polymorphie

  • Threads

  • RMI

  • Jini

  • JavaSpace


Urspr nge von java

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

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

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

Elementare Typen

  • Ganzzahlige Typen:

    byte8 Bits(byte)42-128 bis 127

    short16 Bits(short)42-32.768 bis 32.767

    int32 Bits42-2.147.483.648 bis 2.147.483.647

    long64 Bits42L-9.223.372.036.854.775.808 bis

    9.233.372.036.854.775.807

  • Dezimaltypen:

    float32 Bits42.0F-3.4*1038 bis 3.4*1038

    double64 Bits42.0-1.8*10308 bis 1.8*10308

  • Zeichentyp:

    char16 Bits‘A‘Zeichen und Symbole

  • Logischer Typ:

    booleantruetrue, false


Operatoren

Operatoren

  • Zuweisung:

    =Zuweisung

  • Vergleichsoperatoren für Zahlen und Zeichen:

    ==ist gleich equalsist 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

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

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

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

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


Threads

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


Implementation von threads variante 1

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 threads variante 11

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 threads variante 2

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();


Gegen berstellung der beiden implementationen

Gegenüberstellung der beiden Implementationen


Threads beenden

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

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

Lebenszyklus von Java-Threads


Synchron oder asynchron

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 istSystem.out.println( t.result );}}


Synchronisation mit synchronized

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

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

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


Class java lang thread methoden 2

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

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

  • 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

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

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

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

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

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;}}


Java

RMIC


Stubs und skeletons 1

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

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

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

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

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

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

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

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 (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

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 beispiel

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();}

}

}


Quellen

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

Fragen ?


  • Login