next up previous contents index
Next: Zustand eines Threads Up: Parallelausführung Previous: Parallelausführung

Starten von Threads

Die Klasse Thread steht in der Bibliothek java.lang zur Verfügung.

Es gibt zwei Arten, Threads zu definieren und zu starten:

1. Möglichkeit

Definiere eine Unterklasse von Thread. Überschreibe deren Methode run.  Dann werden Objekte dieser Unterklasse erzeugt und gestartet (Methode start).

  class PrimThread extends Thread 
  { long minPrim;
    PrimThread(long minPrim) 
    { this.minPrim = minPrim;
    }
    public void run() 
    { // Berechne Primzahlen 
      // größer als minPrim
      . . .
    }
  }

Starten durch:

  PrimThread p = new PrimThread(143);
  p.start();

2. Möglichkeit

Definiere ein Klasse, die das Interface Runnable   implementiert. Erzeuge ein Objekt dieser Klasse, übergebe es als Argument der Thread-Erzeugung und starte den erzeugten Thread.

  class PrimRun implements Runnable 
  { long minPrim;
    PrimRun(long minPrim) 
    { this.minPrim = minPrim;
    }
    public void run() 
    { // Berechne Primzahlen 
      // größer als minPrim
      . . .
    }
  }

Starten durch:

  PrimRun p = new PrimRun(143);
  new Thread(p).start();

class uthread extends Thread 
{ public uthread(String str) 
  { super(str); // Thread hat einen Namen
  }
  public void run() 
  { for (int i = 0; i < 5; i++) 
    { System.out.println(i+" "+getName());
       try 
       { sleep((int)(Math.random()*1000));
       } 
       catch (InterruptedException e) {}
    }
  System.out.println("1998: "+getName());
  }
}

class Urlaub 
{ public static void main (String[] args) 
  { new uthread("Sauerland").start();
    new uthread("Malediven").start();
  }
}

Könnte z.B. folgende Ausgabe erzeugen:

   0 Sauerland
   0 Malediven
   1 Sauerland
   2 Sauerland
   3 Sauerland
   1 Malediven
   4 Sauerland
   1998: Sauerland
   2 Malediven
   3 Malediven
   4 Malediven
   1998: Malediven

Wichtiges Anwendungsfeld für Threads sind auch Applets. Sie brauchen Threads, um die Anzeige regelmäßig auffrischen zu können ohne andere Abläufe zu behindern.

Beispiel: Digitaluhr

import java.awt.Graphics;
import java.util.Date;

public class Clock 
extends java.applet.Applet 
implements Runnable 
{ Thread digital;
  public void start() 
  { if (digital == null) 
    { digital = new Thread(this, "Clock");
      digital.start();
    }
  }
  public void run() 
  { while (digital != null) 
    { repaint();
      try { Thread.sleep(1000);} 
      catch (InterruptedException e){}
    }
  }
  public void paint(Graphics g) 
  { g.drawString
        (new Date().toString(), 5, 10);
  }
  public void stop() 
  { digital = null;
  }
}


next up previous contents index
Next: Zustand eines Threads Up: Parallelausführung Previous: Parallelausführung

Peter Pfahler, 1997