thread timeout

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

Code:

---

// 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:

Code:

---

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?

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

Code:

---

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();

---