Re: Concurrency and restarting tasks

On Tue, 26 Feb 2013 08:09:14 -0800 (PST), me 2 wrote:


If I understand your problem correctly, the following should be helpful -
but do read why Thread.stop was deprecated. It would be much, much better
if you could change your design to avoid needing it. With that disclaimer:

package com.usenet.watchdog;

import java.net.Socket;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class WatchDog {
    private final long LIMIT = 5000; // 10
seconds

    private final DateFormat DF = new SimpleDateFormat("mm 'minutes,' ss
'seconds,' S 'milliseconds'");
    private final long START = System.currentTimeMillis();

    private WorkerThread worker;

    private String timestamp() {
        return DF.format(new Date(System.currentTimeMillis() - START));
    }

    private class WorkerThread extends Thread {
        private final Object workload;
        private final long started = System.currentTimeMillis();

        public WorkerThread(final Object workload) {
            this.workload = workload;
        }

        @Override
        public void run() {
            System.out.println(timestamp() + " - (WorkerThread) started");
            System.out.println(timestamp() + " - (WorkerThread) doing stuff with " +
workload);
            while (true) {
                if (System.currentTimeMillis() % 1000 == 0) {
                    System.out.println(timestamp() + " - (WorkerThread) ping");
                }
            }
        }
    }

    private class WatchdogThread extends TimerTask {
        @Override
        public void run() {
            System.out.println(timestamp() + " - (WatchdogThread) checking if worker
thread is over the time limit");
            if (System.currentTimeMillis() - worker.started > LIMIT) {
                System.out.println(timestamp() + " - (WatchdogThread) worker has been
working too long, resetting it");
                worker.stop();
                final Object workload = worker.workload;
                worker = new WorkerThread(workload);
                worker.start();
            }
        }
    }

    public static void main(final String[] args) {
        new WatchDog().start();
    }

    private void start() {
        System.out.println(timestamp() + " - (main) Starting run");
        worker = new WorkerThread(new Socket());
        worker.start();
        final Timer timer = new Timer();
        timer.scheduleAtFixedRate(new WatchdogThread(), 1000, 863);
    }
}

A somewhat more readable version, including some example output, can be
seen here:

<http://pastebin.com/5gcLPS8D>

And a good writeup of why not to use Thread.stop - basically, any objects
the stopped Thread touched (in this case workload) could be damaged beyond
repair. Read more at:

<http://docs.oracle.com/javase/1.5.0/docs/guide/misc/threadPrimitiveDeprecation.html>

Liebe Gruesse,
        Joerg

--
Ich lese meine Emails nicht, replies to Email bleiben also leider
ungelesen.