thread timeout

[Pouncer]

i found this on the net, which is a thread timeout:


// TimeKiller - kill a thread after a given timeout has elapsed

import java.io.*;
import java.util.*;

/// Kill a thread after a given timeout has elapsed
// <P>
// A simple timeout class. You give it a thread to watch and a timeout
// in milliseconds. After the timeout has elapsed, the thread is killed
// with a Thread.stop(). If the thread finishes successfully before then,
// you can cancel the timeout with a done() call; you can also re-use the
// timeout on the same thread with the reset() call.
// <P>

public class TimeKiller implements Runnable
{

private Thread targetThread;
private long millis;
private Thread watcherThread;
private boolean loop;
private boolean enabled;

/// Constructor. Give it a thread to watch, and a timeout in milliseconds.
// After the timeout has elapsed, the thread gets killed. If you want
// to cancel the kill, just call done().
public TimeKiller( Thread targetThread, long millis )
{
this.targetThread = targetThread;
this.millis = millis;
watcherThread = new Thread( this );
enabled = true;
watcherThread.start();
// Hack - pause a bit to let the watcher thread get started.
try
{
Thread.sleep( 100 );
}
catch ( InterruptedException e ) {}
}

/// Constructor, current thread.
public TimeKiller( long millis )
{
this( Thread.currentThread(), millis );
}

/// Call this when the target thread has finished.
public synchronized void done()
{
loop = false;
enabled = false;
notify();
}

/// Call this to restart the wait from zero.
public synchronized void reset()
{
loop = true;
notify();
}

/// Call this to restart the wait from zero with a different timeout value.
public synchronized void reset( long millis )
{
this.millis = millis;
reset();
}

/// The watcher thread - from the Runnable interface.
// This has to be pretty anal to avoid monitor lockup, lost
// threads, etc.
public synchronized void run()
{
Thread me = Thread.currentThread();
me.setPriority( Thread.MAX_PRIORITY );
if ( enabled )
{
do
{
loop = false;
try
{
wait( millis );
}
catch ( InterruptedException e ) {}
}
while ( enabled && loop );
}
if ( enabled && targetThread.isAlive() )
targetThread.stop();
}


/******************************************************************************
/// Test routine.
public static void main( String[] args )
{
System.out.println( (new Date()) + " Setting ten-second timeout..." );
TimeKiller tk = new TimeKiller( 10000 );
try
{
System.out.println(
(new Date()) + " Starting twenty-second pause..." );
Thread.sleep( 20000 );
System.out.println(
(new Date()) + " Another twenty-second pause..." );
Thread.sleep( 20000 );
}
catch ( InterruptedException e )
{
System.out.println(
(new Date()) + " Caught InterruptedException" );
}
catch ( ThreadDeath e )
{
System.out.println( (new Date()) + " Caught ThreadDeath" );
throw e;
}
System.out.println( (new Date()) + " Oops - pauses finished!" );
}
******************************************************************************/

}


My thread looks like this:


class ThreadMove implements Runnable {
ComputerPlayerInterface object;
GameData gameData;
long timeout;

public static boolean done = false;

public static GameAnswer gameAnswer = null;

public void msgbox(String message) {
JOptionPane.showMessageDialog(null, message);
}

public ThreadMove(ComputerPlayerInterface o, GameData gd, long t) {
object = o;
gameData = gd;
timeout = t;
}

public void run() {
try {
gameAnswer = object.doPlay(gameData);
done = true;
}

catch (Exception e) {
msgbox("From thread " + e.toString());
}
}
}


Can anyone help me add this timeout into my thread, so the thread will just automatically close after 'timeout' millisecs?

[weslei]

Well, it was posted a while ago... But nobody answered.
I hope this can help:

long timeout = 60000;
ThreadMove tmtarget = null;
//initialize ThreadMove here: tmtarget = new ThreadMove(parameters);
Thread tm = new Thread(tmtarget);
Thread t = new Thread(new TimeKiller(tm,timeout));
t.start();