Остановка цикличного выполнения распараллеливает в Java

Я думаю, что ваши два случая на самом деле демонстрируют одинаковое потенциальное поведение. Во втором случае рассмотрим, как поток A добавляет событие DeathEvent, после которого поток B добавляет FooEvent. Когда ваш поток задания получает событие DeathEvent, за ним по-прежнему существует FooEvent, что является тем же сценарием, который вы описываете в Варианте 1, если вы не пытаетесь очистить очередь перед возвратом, но тогда вы по существу сохраняете поток живым, когда вы пытаются сделать, это остановить.

Я согласен с вами, что первый вариант более желателен. Возможное решение будет зависеть от того, как заполнена ваша очередь. Если он является частью вашего класса рабочего потока, вы можете настроить свой метод stopThisThread () на установку флага, который будет возвращать соответствующее значение (или генерировать исключение) из вызова постановки в очередь, то есть:

MyThread extends Thread{
  boolean running = true;

  public void run(){
    while(running){
      try{
        //process queue...
      }catch(InterruptedExcpetion e){
        ...
      }
    }
  }

  public void stopThisThread(){
    running = false;
    interrupt();
  }

  public boolean enqueue(Object o){
    if(!running){
       return false;
         OR
       throw new ThreadNotRunningException();
    }
    queue.add(o);
    return true;
  }
}

Тогда ответственность за это будет ложиться на объект пытается поставить событие в очередь, чтобы обработать его надлежащим образом, но, по крайней мере, он будет знать, что событие не находится в очереди, и не будет обработано.

Почему бы не использовать планировщик, который можно просто остановить при необходимости? Стандартный планировщик поддерживает повторное планирование, которое также ожидает завершения рабочего потока перед изменением расписания нового запуска.

ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();
service.scheduleWithFixedDelay(myThread, 1, 10, TimeUnit.SECONDS);

этот пример будет запускать ваш поток с задержкой в ​​10 секунд, это означает, что по завершении одного запуска он перезапускается через 10 секунд. И вместо того, чтобы изобретать велосипед, вы получаете

service.shutdown()

, в while (true) больше нет необходимости.

ScheduledExecutorService Javadoc

Я обычно помещаю флаг в класс, в котором есть поток, и в моем коде потока я бы сделал это. (ПРИМЕЧАНИЕ: вместо while (true) я делаю while (flag))

Затем создайте метод в классе, чтобы установить флаг в false;

private volatile bool flag = true;

public void stopThread()
{
   flag = false;
}

    public void run() {
        Object obj;
        while(flag) {
            synchronized(objectsQueue) {
                if(objectesQueue.isEmpty()) {
                    try {
                        objectesQueue.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    obj = objectesQueue.poll();
                }
            }

            // Do something with the Object obj
        }
    }

В потоке чтения есть логическая остановка переменной. Если вы хотите, чтобы этот поток остановился, установите для thius значение true и прервите поток. В потоке чтения, когда это безопасно (когда у вас нет необработанного объекта), проверьте состояние переменной остановки и вернитесь из цикла, если она установлена. как показано ниже.

public class readerThread extends Thread{
    private volitile boolean stop = false;
    public void stopSoon(){
        stop = true;
        this.interrupt();
    }
    public void run() {
        Object obj;
        while(true) {
            if(stop){
                return;
            }
            synchronized(objectsQueue) {
            if(objectesQueue.isEmpty()) {
                try {
                    objectesQueue.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if(stop){
                    return;
                }    
                obj = objectesQueue.poll();
                // Do something with the Object obj
            }
        }
    }


}
public class OtherClass{
     ThreadReader reader;
     private void start(){
          reader = ...;
          reader.start();
     }

     private void stop(){
          reader.stopSoon();
          reader.join();     // Wait for thread to stop if nessasery.
     }
}

Подход 1 является предпочтительным.

Просто установите для поля volatile stop значение true и вызовите interrupt () в работающем потоке. Это заставит любые методы ввода-вывода, которые ожидают возврата, с InterruptedException (и, если ваша библиотека написана правильно, это будет обработано корректно).