How handling Threads with a specific timeout

Question

Hi all,
first - sorry for my english - i hope you get my problem
I have the following issue:
I have a bunch of threads which take their time. But I want to limit their time and so use a timeout. So e.g. I want to say that all threads have to be finished after 30s, otherwise they will be interrupted/shutdown or whatever.
I had a look at the Executor and ExecutorCompletionService which I actually think they are cool.
But if I use the pull method with a timeout 30sec - doesnt it work like that:
1. try to get the first finished task - wait up to 30secs
2. after getting the result from the first task or after waiting 30secs - try to get another result or wait 30secs
3. after that - again get the next result or wait 30secs.
so actually I could wait for some minutes untill every thread is finished because I always wait up to 30secs.
So my question is - how can I realise, that after 30secs the threads are finished somehow... is this possible via the concurrency package or has it coded differently ?
Thanks
andreas

Answer 1

Hi,
It is not possible to inform the Thread that it has to expire after certain time. When the Thread starts, there can be a loop condition inside the run() method which control some boundary conditions as in the previous post
Take a look at the below classes it may give you some ideas?
There is another possible way if you take a look at Process as a sample below which may help
public static synchronized Process exec(String command, String[] envp, long interval, long timeout)
     throws IOException, InterruptedException
          Process     process = null;
          if (null == envp)
               process = Runtime.getRuntime().exec(command);
          else
               process = Runtime.getRuntime().exec(command, envp);
          return processTimeout(process, interval,timeout);
     } // exec
private static synchronized Process processTimeout(Process process, long interval, long timeout)
     throws InterruptedException
          long     time_waiting = 0;
          boolean     process_finished = false;
          while (time_waiting < timeout &&
                  !process_finished)
               process_finished = true;
               try
                    Thread.sleep(interval);
               catch (InterruptedException e)
                    e.fillInStackTrace();
                    throw e;
               try
                    process.exitValue();
               catch (IllegalThreadStateException e)
                    // process hasn't finished yet
                    process_finished = false;
               time_waiting += interval;
          if (process_finished)
               return process;
          else
               process.destroy();
               return null;
     } // processTimeout
// what about the bloew it may give you an idea!!!!!!!!!!!!!!
public class Timeout
private long _duration;
    private long _now;
    private Task _head;
    public static class Task
        public void unlink()
            _next._prev = _prev;
            _prev._next = _next;
            _next = _prev = this;
            _timeout = null;
            _expired = false;
        public void setNext(Task task)
            if(_timeout == null || task._timeout != null && task._timeout != _timeout || task._next != task)
                throw new IllegalStateException();
            } else
                Task next_next = _next;
                _next._prev = task;
                _next = task;
                _next._next = next_next;
                _next._prev = this;
                _next._timeout = _timeout;
                return;
        public void schedule(Timeout timer)
            unlink();
            timer.schedule(this);
        public void schedule(Timeout timer, long delay)
            unlink();
            timer.schedule(this, delay);
        public void reschedule()
            Timeout timer = _timeout;
            unlink();
            timer.schedule(this, _delay);
        public void cancel()
            _timestamp = 0L;
            unlink();
        public boolean isExpired()
            return _expired;
        public void expire()
        private void doExpire()
            synchronized(this)
                _expired = true;
                expire();
        Task _next;
        Task _prev;
        Timeout _timeout;
        long _delay;
        long _timestamp;
        boolean _expired;
        public Task()
            _timestamp = 0L;
            _expired = false;
            _next = _prev = this;
    public Timeout()
        _head = new Task();
        _head._timeout = this;
    public long getDuration()
        return _duration;
    public void setDuration(long duration)
        _duration = duration;
    public void setNow()
        _now = System.currentTimeMillis();
    public long getNow()
        return _now;
    public void setNow(long now)
        _now = now;
    public Task expired()
        long _expiry = _now - _duration;
        if(_head._next != _head)
            Task task = _head._next;
            if(task._timestamp > _expiry)
                return null;
            task.unlink();
            synchronized(task)
                task._expired = true;
            return task;
        } else
            return null;
    public void tick()
        long _expiry = _now - _duration;
        do
            if(_head._next == _head)
                break;
            Task task = _head._next;
            if(task._timestamp > _expiry)
                break;
            task.unlink();
            try
                task.doExpire();
            catch(Throwable th)
                Log.warn("EXCEPTION ", th);
        } while(true);
    public void schedule(Task task)
        schedule(task, 0L);
    public void schedule(Task task, long delay)
        if(task._timestamp != 0L)
            task.unlink();
            task._timestamp = 0L;
        task._expired = false;
        task._delay = delay;
        task._timestamp = _now + delay;
        Task last;
        for(last = _head._prev; last != _head && last._timestamp > task._timestamp; last = last._prev);
        last.setNext(task);
    public void cancelAll()
        _head._next = _head._prev = _head;
    public boolean isEmpty()
        return _head._next == _head;
    public long getTimeToNext()
        if(_head._next == _head)
            return -1L;
        } else
            long to_next = (_duration + _head._next._timestamp) - _now;
            return to_next >= 0L ? to_next : 0L;
    public String toString()
        StringBuffer buf = new StringBuffer();
        buf.append(super.toString());
        for(Task task = _head._next; task != _head; task = task._next)
            buf.append("-->");
            buf.append(task);
        return buf.toString();
} // TimeOutI hope this can assist in a further step to solve your problem
Have a nice day
Alan Mehio
London, UK
Edited by: alan_mehio on Oct 10, 2007 9:30 AM