Java: обнаружение «тупика» в неявных очередях во время отладки точки останова

Question

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

Это работает нормально, но когда я устанавливаю точки останова в Eclipse в определенных потоках(например, поток рассылки событий Swing), у меня есть ограниченное количество времени, прежде чем JVM останавливается: входящие данные все еще обрабатываются, и некоторая системная очередь, будь то очередь данных или очередь событий, переполняется.

Можно ли как-то обнаружить это в восходящих потоках, чтобы моя восходящая обработка начала отбрасывать данные во время отладки?

Если моя программа явно использует очередьЯ могу просто выбросить данные, когда размер очереди становится слишком большим.

Но я не могу этого сделать, если очередь "неявная", например, она управляется каким-то другим программным обеспечением вне моего прямого контроля.Я могу думать о двух возможностях:

1. Если я использую SwingUtilities.invokeLater() или другую инфраструктуру пользовательского интерфейса, которая вызывает SwingUtilities.invokeLater (), как я могу обнаружитьрезервное копирование потока диспетчера с событиями?

2. Если я использую ExecutorService.submit(), как я могу определить, выполняется ли резервное копирование очереди задач исполнителя?

---

обновление: я думаю, что я решил # 2, обернув свой ExecutorService:

AbstractPipelineExecutor.java:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.RejectedExecutionException;

/**
 * pipeline executor
 */
abstract public class AbstractPipelineExecutor {
    /**
     * a pipeline scheduled item
     */
    public interface Task extends Runnable
    {
        /**
         * if item cannot be run, this is called instead
         */
        public void denied();
    }

    final private ExecutorService executor;

    public AbstractPipelineExecutor(ExecutorService executor)
    {
        this.executor = executor;
    }

    /**
     * submit an item to be executed
     * @param task pipeline item
     */
    public Future<?> submit(final Task task)
    {
        Future<?> result = null;
        if (this.executor.isShutdown())
        {
            task.denied();
        }
        else
        {
            try
            {
                onSubmit(task);
                result = this.executor.submit(new Runnable() {
                    @Override public void run()
                    {
                        onBeginExecute(task);
                        try
                        {
                            task.run();
                        }
                        catch (RuntimeException e)
                        {
                            onExecutionException(task, e);
                        }
                        finally
                        {
                            onEndExecute(task);
                        }
                    }
                });
            }
            catch (RejectedExecutionException e)
            {
                task.denied();
            }
        }
        return result;
    }


    /**
     * event handler: item is submitted
     * @param task pipeline item 
     */
    abstract protected void onSubmit(Task task) throws RejectedExecutionException;
    /**
     * event handler: item execution is begun
     * @param task pipeline item 
     */
    protected void onBeginExecute(Task task) {}
    /**
     * event handler: item throws a runtime exception
     * @param task pipeline item 
     */
    protected void onExecutionException(Task task, RuntimeException e) {
        throw(e);
    }
    /**
     * event handler: item execution is ended
     * @param task pipeline item 
     */
    protected void onEndExecute(Task task) {}
}

BoundedPipelineExecutor.java:

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.RejectedExecutionException;

public class BoundedPipelineExecutor extends AbstractPipelineExecutor {

    public BoundedPipelineExecutor(ExecutorService executor, int bound) {
        super(executor);
        this.q = new ArrayBlockingQueue<Task>(bound);
    }

    final private ArrayBlockingQueue<Task> q; 

    @Override public void onSubmit(Task task)
    {
        if (!this.q.offer(task))
            throw new RejectedExecutionException(task.toString());
    }
    @Override public void onBeginExecute(Task task)
    {
        this.q.remove();
    }
}

Answer 1

Вместо того, чтобы использовать SwingUtilities.invokeLater непосредственно из ваших классов ввода-вывода, я бы предложил, чтобы они обновили «сумматор», который может принимать обоснованные решения об обновлении пользовательского интерфейса.Даже без точек отладки вы не хотите, чтобы тяжелые операции ввода-вывода заполняли ваш пользовательский интерфейс.

Итак, создайте класс, который получает и обрабатывает ваши данные, и разрешите вашему пользовательскому интерфейсу опрашивать эту информацию с подходящими интервалами.