Ich würde einen zweiten Thread starten, der den ersten überwacht und falls nötig beendet. Der erste Thread müsste vielleicht noch über den zweiten Bescheid wissen, damit er einen Shutdown hinaus zögern kann. Klingt so, als wäre das Observer-Pattern hier passend.

Vielleicht hilft dir aber auch ein java.util.TimerTask. Dessen Doku schreibt dazu:

Zitat

A task that can be scheduled for one-time or repeated execution by a Timer.

Klingt gut.

Mach 2 Threads, einer überwacht den anderen.
mfg Oliver

Zitat von deSertXtall

gibts eigentlich auch ne andere möglichkeit einen Thread zu stoppen ausser mit der stop()? hab version 1.4.2.

Schlechte Idee. Solltest immer einen Blick in die JavaDoc werfen.

Zitat von http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Thread.html#stop()

Deprecated. This method is inherently unsafe. Stopping a thread with Thread.stop causes it to unlock all of the monitors that it has locked (as a natural consequence of the unchecked ThreadDeath exception propagating up the stack). If any of the objects previously protected by these monitors were in an inconsistent state, the damaged objects become visible to other threads, potentially resulting in arbitrary behavior. Many uses of stop should be replaced by code that simply modifies some variable to indicate that the target thread should stop running. The target thread should check this variable regularly, and return from its run method in an orderly fashion if the variable indicates that it is to stop running. If the target thread waits for long periods (on a condition variable, for example), the interrupt method should be used to interrupt the wait. For more information, see Why are Thread.stop, Thread.suspend and Thread.resume Deprecated?.

Die hier beschriebene Methode ist laut JavaDoc die einzig sichere zur Beendung eines Threads.

Mach deine eigene stopNow() methode, welche dazu führt, das run() returned. Dieses stopNow wird von dem anderen Thread aufgerufen.
mfg Oliver

Zitat von Zentor

Mach deine eigene stopNow() methode, welche dazu führt, das run() returned. Dieses stopNow wird von dem anderen Thread aufgerufen.
mfg Oliver

Na du Papagei ;). Irgendwie find ich's ja komisch .. ich poste was, und ein paar Stunden später meldest du dich und schlagst genau das selbe vor.

Der überwachte Thread:

public class MyObservedThread extends Thread {


    private boolean keepRunning = true;


    public void run() {
        while (keepRunning) {
            System.out.println("Hello, World!");
        }
    }


    public void stopThread() {
        keepRunning = false;
    }
}

Der überwachende Thread:

public class MyKillerThread {
    private MyObservedThread _observedThread;


    private int _timeToWaitInSeconds;


    public MyKillerThread(MyObservedThread observedThread,
            int timeToWaitInSeconds) {
        if (observedThread == null) {
            throw new IllegalArgumentException(
                    "Please specify a Thread instance to observe it.");
        }
        if (timeToWaitInSeconds < 0) {
            throw new IllegalArgumentException(
                    "timeToWaitInSeconds should be a positive number.");
        }


        _observedThread = observedThread;
        _timeToWaitInSeconds = timeToWaitInSeconds;
    }


    public void run() {
        try {
            Thread.sleep(_timeToWaitInSeconds * 1000);
        } catch (InterruptedException igonore) {


        } finally {
            _observedThread.stopThread();
        }
    }
}

MyKillerThread erhält eine Instanz eines MyObservedThread, schläft die angegebene Zeit und stoppt den MyObservedThread durch den Aufruf der Methode stopThread(). Diese Methode setzt die interne Variable keepRunning auf false, was zum Abbruch der Schleife und zum Beenden der Methode führt.

Thread.interrupt() unterbricht den Thread. Schau's dir in der Doku an.

Sollte das immer noch nicht helfen: Beschreibe dein Problem genau, sag was du machen willst und was du dir als Ergebnis erwartest. So müssen Helfer nicht ihre Zeit an Lösungen verschwenden, die ohnehin nicht gebraucht werden.