CODEWITHSUNDEEP
javamultithreading
astack
astack

Reputation: 4047

Resume interrupted thread

I want to resume the work of interrupted thread,please let me know some possible solutions for the same.

class RunnableDemo implements Runnable 
{

   public void run() 
   {
    while(thread.isInterrupted())
        {
        try{}
                catch(Exception e){ //exception caught}
        }

   }

}

If exception is caught, thread is interrupted, but even though exception is caught, i want thread to continue its work, so please suggest me some way to overcome this issue.

Thanks in advance

Upvotes: 2

Views: 11817

Answers (5)

isnot2bad
isnot2bad

Reputation: 24444

As others already stated, usually interruption is the proper way to cancel a task. If you really need to implement a non-cancellable task, at least make sure to restore the interrupted-state of the thread when you're done with your non-interruptible work:

public void run() {
    boolean interrupted = false;
    try {
        while (true) {
            try {
                callInterruptibleMethod();
            } catch (InterruptedException ex) {
                interrupted = true;
                // fall through and retry
            }
        }
    } finally {
        if (interrupted) {
            // restore interruption state
            Thread.currentThread().interrupt();
        }
    }
}

(From book: Java Concurrency in Practice)

Upvotes: 1

Mak
Mak

Reputation: 616

I have written a reusable code for getting this feature where thread can be pause and resume. Please find the code below. Your can extend PausableTask and override task() method:

public abstract class PausableTask implements  Runnable{

    private ExecutorService executor = Executors.newSingleThreadExecutor();
    private Future<?> publisher;
    protected volatile int counter;
    private void someJob() {
        System.out.println("Job Done :- " + counter);

    }

    abstract void task();

    @Override
    public void run() {
        while(!Thread.currentThread().interrupted()){
            task();
        }
    }

    public void start(){
        publisher = executor.submit(this);
    }

    public void pause() {
        publisher.cancel(true);
    }

    public void resume() {
        start();
    }

    public void stop() {
        executor.shutdownNow();
    }
}

Hope this helps. For further details check this link or give me shout in comment section. http://handling-thread.blogspot.co.uk/2012/05/pause-and-resume-thread.html

Upvotes: 2

Solomon Slow
Solomon Slow

Reputation: 27115

One caveat: If your thread handles an InterruptedException while in a call to a third-party library, then you won't necessarily know how the library reacted to it (i.e., did it leave the library objects in a state when it makes sense for your program to continue using them?)

Some developers (including some library developers) mistakenly assume that an interrupt means, "shut down the program," and all they worry about is closing files, etc.; and not so much about whether the library can continue to be used.

Try it and see, but if you're writing code to control a spacecraft or a nuclear reactor or something, then you may want to do a little extra work to really find out what the library does.

Upvotes: 1

David Hofmann
David Hofmann

Reputation: 5775

A thread get's interrupted only if someone called the interrupt() method of that thread and not because some other random exception was thrown while running your thread as you are thinking.

When the thread's interrupted() method is called, InterruptedException will be thrown in the thread if the thread is in the middle of a blocking operation (eg. IO read).

When the InterruptedException is thrown you should know that the interrupted status is cleared, so the next time you call isInterrupted() in your thread will give you false (even though you just cauth the InterruptedException)

Have this in mind while coding your threads. And if you don't understand what I am talking about stop coding multithreading and go read some books about concurrency in java.

Upvotes: 1

Duncan Jones
Duncan Jones

Reputation: 69339

Thread interruption is something you choose to obey when writing a thread. So if you don't want your thread to be interrupted, don't check the interrupted status and continue regardless.

The only time you'll need try/catch statements (with respect to thread interruption) is when calling blocking methods that throw InterruptedException. Then you'll need to avoid letting that exception stop your thread's work.

Of course... you should give some thought about whether this is a suitable way to behave. Thread interruption is a helpful thing and choosing not to adhere to it can be annoying to users of your code.

Upvotes: 8

Related Questions