kill java thread and process

Hi all,

I am developping a client server application and I am stuck in a kill
thread/process problem; in my client I start a calculation process
(trough a button), wich will launch a process to do this task; after
the process finishes all computations, the results are displayed into
client window and I kill the process;
I have also a stop button that must stop the process (kill him) - and
by default not display results .

Somehow a can't manage to kill the process BEFORE the he finishes the
computation, but after that. the actual behaviour is the following: the
procces is launched (start button pushed) in the background, I press
stop button but the result are still displayed in the client window and
the process is killed after that.
Here is my code :

public class ProcessMonitoring {

public static Process p;
public static Timer timer;
public static KillingTask killTask;
public static Thread waitForProcess;

public static void exec(File engineDir, String engineName, File
workingDir, long timeOut)
    throws ProcessMonitoringException{
        try {
            p = Runtime.getRuntime().exec((new File(engineDir,
engineName)).getAbsolutePath(),null,workingDir);
            waitForProcess = new MonitorThread(p);
            waitForProcess.setName("computation thread");
            timer = new Timer(false);
            killTask = new KillingTask(p, waitForProcess);
            timer.schedule(killTask,timeOut);
            StreamGobbler stderr = new StreamGobbler(p.getErrorStream(),
StreamGobbler.ERROR);
            StreamGobbler stdin = new StreamGobbler(p.getInputStream(),
StreamGobbler.INPUT);
            stderr.start();
            stdin.start();
            waitForProcess.start();
            waitForProcess.join(timeOut);
            killTask.cancel();
            timer.cancel();
            p.destroy();
            Logger.getInstance().trace("Exit code: " + p.exitValue());
            if (((MonitorThread)waitForProcess).hasBeenInterrupted() ||
p.exitValue() != 0 )
                throw new ProcessMonitoringException("processinterrupted");
         } catch (IOException e) {
             Logger.getInstance().warn("TROUBLE TO FIND ENGINE EXEC\n", e);
             throw new ProcessMonitoringException("execnotfound", e);
         } catch (InterruptedException e) {
             Logger.getInstance().warn("TROUBLE WITH ENGINE PROCESS\n", e);
             throw new ProcessMonitoringException("processinterrupted", e);
         } catch (ProcessMonitoringException e) {
             throw e;
         } catch (Exception e) {
             Logger.getInstance().warn("UNKNOWN ERROR\n", e);
             throw new
ProcessMonitoringException("unknownprocessmonitoringexception", e);
         }
    }

 public static void kill(File engineDir, String engineName, File
workingDir) throws ProcessMonitoringException{
        try {
            if(waitForProcess.getName() == "computation thread"){
                waitForProcess.interrupt();
                killTask.cancel();
                timer.cancel();
                p.destroy();
            }
        } catch (Exception e) {
             Logger.getInstance().warn("UNKNOWN ERROR\n", e);
             throw new
ProcessMonitoringException("unknownprocessmonitoringexception", e);
        }
    }
}

class MonitorThread extends Thread{

    private Process p;
    private boolean hasBeenInterrupted = false;

    public MonitorThread(Process process){
        super();
        p = process;
    }

    public void run(){
        try {
            p.waitFor();
        } catch (InterruptedException e) {
            Logger.getInstance().warn("This process has been interrupted.
\n"+e);
            hasBeenInterrupted = true;
        }
    }

    public boolean hasBeenInterrupted(){
        return hasBeenInterrupted;
    }
}

class KillingTask extends TimerTask{

    private Process process;
    private Thread thread;

    public KillingTask(Process p, Thread t){
        super();
        process = p;
        thread = t;
    }

    public void run() {
        Logger.getInstance().warn("Interrupting process. ");
        process.destroy();
        thread.interrupt();
    }
}

ProcessMonitoring exec and kill functions are called within client side
(start/stop button)

Thank you for your help

Anka