Потребитель темы. Ява

Есть ли какие-нибудь прослушиватели в Java для обработки того, что какой-то поток завершен? Что-то вроде этого:

Future<String> test = workerPool.submit(new TestCalalble());
test.addActionListener(new ActionListener()               
   {                                                         
    public void actionEnd(ActionEvent e)               
    {                                                        
        txt1.setText("Button1 clicked");                        
    }                                                        
   });

Я знаю, что такое дело невозможно, но я хочу, чтобы меня уведомили, когда какой-то поток закончился.

Обычно я использовал этот класс Timer с проверкой состояния каждого Будущего. но это не очень. Благодаря

Ответ 1

Существует CompletionService, который вы можете использовать.

CompletionService<Result> ecs
       = new ExecutorCompletionService<Result>(e);
ecs.submit(new TestCallable());
if (ecs.take().get() != null) {
    // on finish
}

Другой альтернативой является использование ListenableFuture из Guava.

Пример кода:

ListenableFuture future = Futures.makeListenable(test);
future.addListener(new Runnable() {
 public void run() {
   System.out.println("Operation Complete.");
   try {
     System.out.println("Result: " + future.get());
   } catch (Exception e) {
     System.out.println("Error: " + e.message());
   }
 }
}, exec);

Лично мне лучше нравится решение Guava.

Ответ 2

Вы можете реализовать шаблон наблюдателя для завершения отчета.

public interface IRunComplete {
    public void reportCompletion(String message);
}

Позволяет вызывающему потоку реализовать этот интерфейс.

и в методе run() вы вызываете этот метод в конце. Итак, теперь вы точно знаете, когда этот поток закончится.

Попробуйте. Я фактически использую это, и он отлично работает.

Ответ 3

Вот слушатель-гейки. Очень неразумно использовать, но смешно и умно

Thread t = ...
t.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler(){
    @Override
    public void uncaughtException(Thread t, Throwable e) {
        t.getThreadGroup().uncaughtException(t, e);//this is the default behaviour
    }       
    protected void finalize() throws Throwable{
        //cool, we go notified
      //handle the notification, but be worried, it the finalizer thread w/ max priority
    }
});

Эффект может быть достигнут с помощью PhantomRefernce лучше

надеюсь, что у вас есть улыбка:)

Боковое примечание: то, что вы просите, это НЕ конец конца, но событие завершения задачи и наилучшее - это переопределение либо decorateTask, либо afterExecute

Ответ 4

Без добавления большого количества дополнительного кода вы можете сами создать поток быстрого прослушивания следующим образом:

//worker thread for doings
Thread worker = new Thread(new Runnable(){ 
    public void run(){/*work thread stuff here*/}
});
worker.start();
//observer thread for notifications
new Thread(new Runnable(){
    public void run(){
    try{worker.join();}
    catch(Exception e){;}
    finally{ /*worker is dead, do notifications.*/}
}).start();

Ответ 5

Нет. Такого слушателя не существует. Но у вас есть 2 решения.

Добавить код, который уведомляет вас о том, что поток выполняется в конце метода run()
Используйте интерфейс Callable, который возвращает результат типа Future. Вы можете спросить Будущее, что такое статус, и использовать заблокированный метод get() для получения результата.

Ответ 6

У вас есть метод join(), определенный для него классом Thread. Тем не менее, у вас нет прямой видимости для потока, выполняющего ваш Callable в concurrency случае API.

Ответ 7

Используйте этот пример:

public class Main {

    public static void main(String[] args) {

        CompletionListener completedListener = count -> System.out.println("Final Count Value: " + count);

        HeavyWorkRunnable job = new HeavyWorkRunnable(completedListener);

        Thread otherThread = new Thread(job);
        otherThread.start();

    }

    static class HeavyWorkRunnable implements Runnable {

        CompletionListener completionListener;

        public HeavyWorkRunnable(CompletionListener completionListener) {
            this.completionListener = completionListener;
        }


        @Override
        public void run() {

            int count = 0;

            for (int i = 0; i < 10; i++) {

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Clock Tick #"+i);

                count += 1;

            }

            if (completionListener != null) {
                completionListener.onCompleted(count);
            }
        }
    }

    @FunctionalInterface
    interface CompletionListener {

        void onCompleted(int count);

    }
}