Java：ブレークポイントのデバッグ中に暗黙的な待ち行列の「渋滞」を検出しました

Question

シリアルポートを介して到着するデータからデータストリームを処理するJavaアプリケーションがあり、スイングUIに要約を表示します。

これは問題なく動作しますが、特定のスレッド（たとえばSwingイベントディスパッチスレッド）でEclipseにブレークポイントを設定すると、JVMが停止するまでの時間が限られています。それがデータキューであろうとイベントキューであろうと、いくつかのシステムキューが過大になっています。

アップストリームスレッドでこれを検出する方法はありますか。そのため、アップストリーム処理ではデバッグ中にデータが捨てられることがありますか？

私のプログラムが明示的にキューを使用している場合、キューのサイズが大きすぎるとデータを破棄できます。

しかし、キューが「暗黙的」な場合、これはできません。私の直接的な制御を超えて、他のソフトウェアによって管理されています。私は2つの可能性を考えることができます：私はSwingUtilities.invokeLater()、またはSwingUtilities.invokeLaterを（）を呼び出し、別のUIフレームワークを使用している場合は

1. 、私はディスパッチスレッドがイベントにバックアップされているかどうかを検出することができますか？

2. ExecutorService.submit()を使用している場合、どのように実行プログラムのタスクキューがバックアップされているかを検出できますか？

---

アップデート：私は、私は私のExecutorServiceのをラップすることにより、第2位を解決したと思う：

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を使用するのではなく.invokeあなたのIOクラスから直接後で、私は彼らがUIを更新することに関する情報に基づいた意思決定を行うことができます 'summariser'を更新することをお勧めしたいと思います。デバッグブレークポイントがなくても、大量のIO操作でユーザーインターフェイスが溢れないようにします。

したがって、データを受信して​​処理するクラスを作成し、ユーザーインターフェイスが適切な間隔でその情報をポーリングできるようにします。