Java Threads Grundlagen Threads in Java Thread-Synchronisation 200m

							                                       Java Threads




                     Grundlagen



                     Threads in Java


                                                               200m
                     Thread-Synchronisation




ETH Zürich, SS2000                      Java Threads und RMI          Seite 1
                                       Grundlagen



       traditionell:
        •     sequentielle Programme
        •     nur ein Kontrollfluß (Thread)

       wünschenswert:
        •     Programmteile parallel abarbeiten
        •     mehrere Threads
        •     Abarbeitung in einem Thread sequentiell




ETH Zürich, SS2000                       Java Threads und RMI   Seite 2
                                              Grundlagen

                                                                      Thread1              Thread2
                                                                                 int x
                                                                       y=x                   y=x
       Threads:                                                                     5
                                                                       y+=1                  y+=5
        •     laufen im selben Adreßraum ab
              (leichtgewichtige Prozesse)                               x=y      Thread3     x=y

                     • müssen sich synchronisieren                                 y=x
                                                                            6?             10?
                                                                                    11?


                                                                       sehr wichtig
        •     müssen sich eine CPU Teilen
                     • besitzen Prioritäten                                                      C
                                                                                                 P
                     • besitzen verschiedene                              wichtig                U
                       Zustände
                                                                        unwichtig


ETH Zürich, SS2000                             Java Threads und RMI                                  Seite 3
                                       Grundlagen


Thread:
1. erzeugen
2. starten
3. beenden / stoppen                       blocked                    stop()


                                                                                         dead
                                resume()
                                notify()                                    stop()
                                               suspend()
           newborn                             sleep()
                                               wait()                                stop()


                      start()

                                  runnable                                     running
                                                                  yield()


 ETH Zürich, SS2000                        Java Threads und RMI                                 Seite 4
                                        Klasse java.lang.Thread


                                                                              generischer Name
                     Konstruktoren:                                           Thread-<nummer>
                     • public Thread()
                     • public Thread(String name)
                     •   public Thread(Runnable target)                                  Identifikation
                     •   public Thread(Runnable target, String name)
                     Methoden:
                     • void run()
                     •   void start()

                     •   static void sleep(long millis)                static void yield()
                     •   void join()
                     •   void setName()                                String getName()
                     •   void setPriority(int prio)                    int getPriority()
                     •   boolean isAlive()
                     von Object ererbt:
                      • void wait()                                    void notify()



ETH Zürich, SS2000                              Java Threads und RMI                                     Seite 5
                                Threads Synchronisieren


   Zweck:
    •     gegenseitiger Ausschluß
    •     vermeiden gleichzeitigen Objektzugriffs (aus mehreren Threads)
   Lösung: Objekt-Monitore
   Monitor:
   • verwaltet Zugriffe auf ein Objekt
   • immer nur ein Zugriff möglich                                 Keine andere synchronized
   • zwei Zustände: frei --- vergeben                              Methode ausführbar
   Monitor anlegen:
    •     Methoden synchronized deklarieren
    •     synchronized( Object ) { ............}
          verwenden                                              critical
                                                                 regions
                                                                             synchronized(x){
                                                                                y=x;
                                                                                y += 1;
                                                                                x=y;
                                                                             }

ETH Zürich, SS2000                        Java Threads und RMI                             Seite 6
                                        Beispiel

class Konto{
   privat double kontostand;

  public Konto (double x){                                    k.einzahlung(5)
     kontostand = x;
                                                                                 warten
  }
                                                                       k.einzahlung(6)
  public synchronized double stand(){
     return kontostand;                                                                  k.stand()
  }

  public synchronized void einzahlung(double x){
     kontostand += x;
  }


                       nächster Monitorbesitzer
                       ist zufällig




  ETH Zürich, SS2000                   Java Threads und RMI                                Seite 7
                                     Zusammenfassung



               •     Threads ermöglichen paralleles Arbeiten

               •     Ablauf ist nichtdeterministisch

               •     bei Zugriff auf gemeinsame Daten: Synchronisation

               •     Synchronisation durch Objektmonitore

               •     synchronized Objektmethoden

               •     synchronized-Anweisungsblöcke

               •     Synchronisationsfehler sehr schwer zu finden




ETH Zürich, SS2000                        Java Threads und RMI           Seite 8