Обработка исключений для ThreadPoolExecutor

Question

У меня есть следующий фрагмент кода, который в основном просматривает список задач, которые должны быть выполнены, и каждая задача затем передается исполнителю для выполнения.

JobExecutor, в свою очередь, создает другого исполнителя (для выполнения операций с базами данных ... чтения и записи данных в очередь) и выполняет задачу.

JobExecutor возвращает Future<Boolean> для представленных задач. Когда одна из задач не выполняется, я хочу изящно прервать все потоки и завершить работу исполнителя, перехватывая все исключения. Какие изменения мне нужно сделать?

public class DataMovingClass {
    private static final AtomicInteger uniqueId = new AtomicInteger(0);

  private static final ThreadLocal<Integer> uniqueNumber = new IDGenerator();   

  ThreadPoolExecutor threadPoolExecutor  = null ;

   private List<Source> sources = new ArrayList<Source>();

    private static class IDGenerator extends ThreadLocal<Integer> {
        @Override
        public Integer get() {
            return uniqueId.incrementAndGet();
        }
  }

  public void init(){

    // load sources list

  }

  public boolean execute() {

    boolean succcess = true ; 
    threadPoolExecutor = new ThreadPoolExecutor(10,10,
                10, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(1024),
                new ThreadFactory() {
                    public Thread newThread(Runnable r) {
                        Thread t = new Thread(r);
                        t.setName("DataMigration-" + uniqueNumber.get());
                        return t;
                    }// End method
                }, new ThreadPoolExecutor.CallerRunsPolicy());

     List<Future<Boolean>> result = new ArrayList<Future<Boolean>>();

     for (Source source : sources) {
                    result.add(threadPoolExecutor.submit(new JobExecutor(source)));
     }

     for (Future<Boolean> jobDone : result) {
                try {
                    if (!jobDone.get(100000, TimeUnit.SECONDS) && success) {
                        // in case of successful DbWriterClass, we don't need to change
                        // it.
                        success = false;
                    }
                } catch (Exception ex) {
                    // handle exceptions
                }
            }

  }

  public class JobExecutor implements Callable<Boolean>  {

        private ThreadPoolExecutor threadPoolExecutor ;
        Source jobSource ;
        public SourceJobExecutor(Source source) {
            this.jobSource = source;
            threadPoolExecutor = new ThreadPoolExecutor(10,10,10, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(1024),
                    new ThreadFactory() {
                        public Thread newThread(Runnable r) {
                            Thread t = new Thread(r);
                            t.setName("Job Executor-" + uniqueNumber.get());
                            return t;
                        }// End method
                    }, new ThreadPoolExecutor.CallerRunsPolicy());
        }

        public Boolean call() throws Exception {
            boolean status = true ; 
            System.out.println("Starting Job = " + jobSource.getName());
            try {

                        // do the specified task ; 


            }catch (InterruptedException intrEx) {
                logger.warn("InterruptedException", intrEx);
                status = false ;
            } catch(Exception e) {
                logger.fatal("Exception occurred while executing task "+jobSource.getName(),e);
                status = false ;
            }
           System.out.println("Ending Job = " + jobSource.getName());
            return status ;
        }
    }
}   

Answer 1

Когда вы отправляете задачу исполнителю, он возвращает вам экземпляр FutureTask.

FutureTask.get() перезапустит любое исключение, выброшенное задачей, как ExecutorException.

Поэтому, когда вы перебираете List<Future> и вызываете get для каждого, перехватываете ExecutorException и вызываете упорядоченное завершение работы.

Answer 2

Поскольку вы отправляете задачи в ThreadPoolExecutor, исключения поглощаются FutureTask.

Посмотрите на этот код

**Inside FutureTask$Sync**

void innerRun() {
    if (!compareAndSetState(READY, RUNNING))
        return;

  runner = Thread.currentThread();
    if (getState() == RUNNING) { // recheck after setting thread
        V result;
       try {
            result = callable.call();
        } catch (Throwable ex) {
           setException(ex);
            return;
        }
       set(result);
    } else {
        releaseShared(0); // cancel
    }

}

protected void setException(Throwable t) {
   sync.innerSetException(t);
}

Из приведенного выше кода видно, что setException метод перехвата Throwable. По этой причине FutureTask глотает все исключения, если вы используете метод "submit()" в ThreadPoolExecutor

Согласно документации Java , вы можете расширить afterExecute() метод в ThreadPoolExecutor

protected void afterExecute(Runnable r,
                            Throwable t) 

Пример кода согласно документации:

class ExtendedExecutor extends ThreadPoolExecutor {
   // ...
   protected void afterExecute(Runnable r, Throwable t) {
     super.afterExecute(r, t);
     if (t == null && r instanceof Future<?>) {
       try {
         Object result = ((Future<?>) r).get();
       } catch (CancellationException ce) {
           t = ce;
       } catch (ExecutionException ee) {
           t = ee.getCause();
       } catch (InterruptedException ie) {
           Thread.currentThread().interrupt(); // ignore/reset
       }
     }
     if (t != null)
       System.out.println(t);
   }
 }

Вы можете поймать Exceptions тремя способами

1. Future.get() как указано в принятом ответе
2. Обернуть весь run() или call() метод в try{}catch{}Exceptoion{} блоков
3. переопределить afterExecute метода ThreadPoolExecutor, как показано выше

Чтобы изящно прерывать другие потоки, взгляните на вопрос SE ниже:

Как остановить запуск следующего потока в ScheduledThreadPoolExecutor

Как принудительно отключить Java ExecutorService

Answer 3

Подкласс ThreadPoolExecutor и переопределить его protected afterExecute (Runnable r, Throwable t) метод.

Если вы создаете пул потоков с помощью вспомогательного класса java.util.concurrent.Executors (которым вы не являетесь), взгляните на его источник, чтобы увидеть, как он вызывает ThreadPoolExecutor .