shutdown and awaitTermination which first call have any difference?

问题

What is the difference between

ExecutorService eService = Executors.newFixedThreadPool(2);
eService.execute(new TestThread6());
eService.execute(new TestThread6());
eService.execute(new TestThread6());
eService.awaitTermination(1, TimeUnit.NANOSECONDS);
eService.shutdown();

and

eService.shutdown();
eService.awaitTermination(1, TimeUnit.NANOSECONDS);

I don't really understand shutdown(). This method does not wait for previously submitted tasks to complete execution. Does it mean shutdown() may terminate the tasks which have been submitted, but not completed? I tried some examples, they do not prove it, please give me an example.

回答1:

You should call shutdown first. Otherwise, you might be waiting for a very long time, since awaitTermination doesn't actually shut down your executor.

If you wanted to wait for tasks to complete, rather than wait for the executor to shut down, then you should use invokeAll.

回答2:

Reading the documentation always helps:

shutdownNow :

Attempts to stop all actively executing tasks, halts the processing of waiting tasks, and returns a list of the tasks that were awaiting execution. These tasks are drained (removed) from the task queue upon return from this method.

This method does not wait for actively executing tasks to terminate. Use awaitTermination to do that.

There are no guarantees beyond best-effort attempts to stop processing actively executing tasks. This implementation cancels tasks via Thread.interrupt(), so any task that fails to respond to interrupts may never terminate

shutdown:

Initiates an orderly shutdown in which previously submitted tasks are executed, but no new tasks will be accepted. Invocation has no additional effect if already shut down.

This method does not wait for previously submitted tasks to complete execution. Use awaitTermination to do that.

awaitTermination:

Blocks until all tasks have completed execution after a shutdown request, or the timeout occurs, or the current thread is interrupted, whichever happens first.

回答3:

shutdown means the executor service takes no more incoming tasks.

awaitTermination is invoked after a shutdown request.

You need to first shut down the service and then block and wait for threads to finish.

If you want to see all threads finish running and insist on using awaiTermination, you need to set the timeout parameter to be big enough. So you could do:

eService.shutdown();
if (!eService.awaitTermination(60000, TimeUnit.SECONDS))
    System.err.println("Threads didn't finish in 60000 seconds!");
}

Alternatively, you could do:

eService.shutdown();
while (!eService.isTerminated()) {

}

This way you are able to ensure all threads are finished running unless they are interrupted unexpectedly.

回答4:

After we start the first task ThreadPoolExecutor will start a Thread that will not end even after the task is finished. At least it's true for a fixed thread pool. This is why we need to call shutdown. After shutdown ThreadPoolExecutor will reject any new task but will wait for running tasks to finish and then allow the Threads to end. This is why we need awaitTermination after shutdwon.

回答5:

Main Difference

shutdown()-

1. Not block the calling a thread - means a thread who called the shutdown().
2. Excecutor not accepting new task after calling shutdown().

awaitTermination -

1. Block the calling thread. (as join() method do)

Confusion Point - because shutdown() not killing the previously submitted task , then why awaitTermination()

shutdown() also not kill any task which is previously submitted means submitted tasks and currently running tasks are allowed to continue , then why need awaitTermination().

Suppose you can wait for 10 min only to complete all the task that are submitted and after that want to call shutdownNow()(---you already know what it do) then use awaitTermination() after calling shutdown().

And if there is no time restriction , then shutdown() is ok. No need of awaitTermination().

回答6:

executorService.execute(runnableTask);  

//executorService.shutdown(); //it will make the executorService stop accepting new tasks
//executorService.shutdownNow(); //tires to destroy the executorService immediately, but it doesn't guarantee that all the running threads will be destroyed at the same time. This method returns list of tasks which are waiting to be processed.
//List<Runnable> notExecutedTasks = executorService.shutdownNow(); //this method returns list of tasks which are waiting to be processed.developer decide what to do with theses tasks?

//one good way to shutdown the executorService is use both of these methods combined with the awaitTermination
executorService.shutdown();
try{
    if(!executorService.awaitTermination(1000, TimeUnit.MICROSECONDS)) {
        executorService.shutdownNow();
    }
}catch (InterruptedException e){
    e.printStackTrace();
}

回答7:

From Java8 ThreadPool awaitTermination method:

    try {
        for (;;) {
            if (runStateAtLeast(ctl.get(), TERMINATED))
                return true;
            if (nanos <= 0)
                return false;
            nanos = termination.awaitNanos(nanos);
        }
    } finally {
        mainLock.unlock();
    }

It will first check run state of thread pool. And if the thread pool is not shut down(which set run state to terminated), awaitTermination method will not return until timeout. This explains why await a long time if you await first then shutdown.

回答8:

the best implementation:

executor.shutdown();
    try {
         if (!executor.awaitTermination(3500, TimeUnit.MILLISECONDS)) {
            executor.shutdownNow();
         }                  
    } catch (InterruptedException e) {              
        executor.shutdownNow();
    }

回答9:

You need to call shutdownNow() method after the awaitTermination() method call happened. Then only you can find out the actual usage of awaitTermination() method.

来源：https://stackoverflow.com/questions/18425026/shutdown-and-awaittermination-which-first-call-have-any-difference

标签

java

multithreading

executorservice