9.3 Threads schlafen

Manchmal ist es notwendig, einen Thread für eine bestimmte Zeit anzuhalten. Dazu dient die überladende Klassenfunktion sleep(). Etwas erstaunlich ist sicherlich, dass das keine Objektfunktion ist, die jedes Thread-Objekt anbietet, sondern eine statische Funktion. Ein Grund wird sein, dass dadurch verhindert wird, externe Threads zu beeinflussen. Es ist nicht möglich, einen fremden Thread, dessen Referenz wir haben, einfach ein paar Sekunden schlafen zu legen.

class java.lang.Thread
implements Runnable

static void sleep( long millis ) throws InterruptedException Der aktuell ausgeführte Thread wird mindestens millis Millisekunden eingeschläfert. Unterbricht ein anderer Thread den schlafenden, so wird vorzeitig eine Interrupted Exception ausgelöst.

static void sleep( long millis, int nanos ) throws InterruptedException Der aktuell ausgeführte Thread wird mindestens millis Millisekunden und zusätzlich nanos Nanosekunden eingeschläfert. Im Gegensatz zu sleep(long) wird bei einer negativen Millisekundenanzahl eine IllegalArgumentException ausgelöst, ebenso wird diese Exception ausgelöst, wenn die Nanosekundenanzahl nicht zwischen 0 und 999999 liegt.

try {
  Thread.sleep( 2000 );
} catch ( InterruptedException e ) { }

Die Unterbrechung sitzt in einem zwingenden try/catch-Block, da eine Exception ausgelöst wird, wenn der Thread unterbrochen wird.

Praktisch wird das Erweitern der Klasse Thread bei inneren anonymen Klassen. Die folgende Klasse SleepInInnerClass gibt nach zwei Sekunden Schlafzeit eine Meldung auf dem Bildschirm aus. Wir starten den Thread dabei aus dem Objekt-Initialisierungsblock. Natürlich hätten wir auch direkt auf der anonymen Unterklasse die Methode start() aufrufen können.

Listing 9.3 SleepInInnerClass.java

public class SleepInInnerClass
{
  public static void main( String args[] )
  {
    new Thread() {
      { start(); } 
        {
        public void run() {
          try { sleep(2000); System.out.println("Zeit ist um."); }
          catch ( InterruptedException e ) { }
        } };
  }
}

9.3.1 Eine Zeituhr

Die sleep()-Methode kann auch effektiv zum Warten benutzt werden. Soll ein Programm zu einer bestimmten Zeit eine Aufgabe ausführen, beispielsweise um 18 Uhr eine Nachricht senden, wenn die Simpsons im Fernsehen laufen, so kann ein Thread eingesetzt werden.

Listing 9.4 Clock.java

import java.util.*;
class Clock extends Thread
{
  Calendar cal = new GregorianCalendar();
   public Clock( int timeHour, int timeMinute, String title )
  {
    wakeHour   = timeHour;
    wakeMinute = timeMinute;
    this.title = title;
    start();
  }
  public Clock( int timeHour, String title )
  {
    this ( timeHour, 0, title );
  }
  public void run()
  {
    boolean checked = false;
    while ( true )
    {
      try
      {
        cal.setTime( new Date() );
        if ( cal.get( Calendar.HOUR_OF_DAY ) == wakeHour &&
             cal.get( Calendar.MINUTE ) == wakeMinute )
        {
          if ( !checked )
          {
            // hier nun Arbeit verrichten
            System.out.println( title );
            checked = true;
          }
        }
        Thread.sleep( 1000*10 );   // 10 Sekunden schlafen
      }
      catch ( InterruptedException e ) {};
    }
  }
  private int wakeHour, wakeMinute;
  private String title;
  public static void main( String args[] )
  {
    Clock clock = new Clock( 18, "Simpsons kommt" );
  }
}