捕获异常后重新启动线程

Question

I am reading a UDP feed and I want the thread to attempt to restart if their is a failure. I think I have written my class correctly but would like someone to look over and see if there is something missing or I have written something that won't get the job done. In my catch clause I attempt to restart the thread every 6 seconds for 10 attempts. Is this a good solution, will it work?

class UDPReader extends Thread
{
    private Thread t;
    private final String ip, socket, queue, threadName;
    private String ErrorMessage;
    private final JTextArea screen;

    UDPReader(String ip, String socket, String queue, String threadName, JTextArea screen) {
        this.ip = ip;
        this.socket = socket;
        this.queue = queue;
        this.threadName = threadName;
        this.screen = screen;
    }

    public void run()
    {
        try {
            byte[] i = null;
            ipaddrConnection ipaddr = new ipaddrConnection(ip, socket);
            parseUDP p = new parseUDP();

            screen.append("Thread " + threadName + " running\n");
            while(true)
            {
                i = ipaddr.getPacket();
                p.parseUDP(i); 
                //Thread.sleep(0);
            }
        } 
        catch (IOException ex) {
            Logger.getLogger(MarketDataReader.class.getName()).log(Level.SEVERE, null, ex);
            ErrorMessage = "Thread " + threadName + " has failed, Attempting to Restart";
            screen.append("Thread " + threadName + " has failed, Attempting to Restart\n");
            Email email = new Email(ErrorMessage,"WARNING Market Data Reader Failure");

            for(int i = 0; i < 10 && t.isAlive() == false; i++)
            {
                try {
                    start();
                    Thread.sleep(6000);
                } catch (InterruptedException ex1) {
                    Logger.getLogger(UDPReader.class.getName()).log(Level.SEVERE, null, ex1);
                    ErrorMessage = "Thread " + threadName + " has failed, Contact System Administraitor";
                    screen.append("Thread " + threadName + " has failed, Contact System Administraitor\n");
                    email = new Email(ErrorMessage,"WARNING Market Data Reader Failure");
                }
            }
        }
    }

    public void start() 
    {
        if (t == null)
      {
         t = new Thread (this, threadName);
         t.start ();
      }
    }
}

Answer 1

I do not know the logic behind your thread in detail but I would make some suggestions on the design of your code.

1. It is not clear why inside a class derived from thread you have another thread t.

2. There is no need to derive from Thread (and I believe it is generally a bad practice). It is common to rather implement Runnable interface and then construct a new thread using it.

.

class UDPReader implements Runnable {
...
}

and then instantiate a thread like this:

Thread t = new Thread(new UDPReader());

3. As a rule, if a thread fails, it terminates... It does not look good that a failed thread "recreates" itself. The better solution would be to provide a Thread.UncaughtExceptionHandler and in the code that creates your thread analyze failing conditions and restart you thread if needed.

In general, not to mess up, in concurrent programming you have to clearly distinguish the logic of a thread and external logic that manages this thread (its start/interruption/termination). I think, this is what you did not do in your code.

Answer 2

I'd say that it is a very bad design to restart a thread from inside of the same thread.

If you need a 'supervisor' thread then you should most likely create another 'supervisor' thread that would create and start the 'worker' thread whenever it finds out that 'worker' thread is down.

Answer 3

One thing you should be aware of is that when you catch an exception in Java, the program (or thread) does not terminate unless you tell it too.

Therefore, if you caught your exception exactly at the command that caused it to happen - inside the loop - you would not need to run another thread. Your thread is alive and will continue to loop. All you need to do - inside the catch block - is fix things up so that the next loop can continue as usual - close and reopen streams, clear partially filled data structures, stuff like that.

Of course, if further, unrecoverable exceptions happen, you should indeed stop your thread.