SwingConsolePane: first cut at batching the output

We want to avoid an excessive amount of queuing to the EDT via
EventQueue.invokeLater calls. This change puts all output events into a
queue, which is fully drained by each Runnable queued up on the EDT.
Concurrent appends push the new output events into the queue, but only
queue up a new Runnable on the EDT if there isn't one already running.

Concurrency issues are always tricky, but I _think_ this logic is
thread-safe. It is OK that an extra Runnable or two might get queued up
on the EDT. The danger is the inverse situation: that the append method
might opt not to queue up a Runnable, even though the currently active
Runnable on the EDT is already winding down. If that happened, the
appearance of some output might be delayed by an arbitrarily lengthy
period, until the next bit of output rolls around...

In the case of SwingConsolePaneBenchmark, this change reduces the
number of threadService.queue calls from >2000 to a mere _2_ calls!

However, the improvement in real time is not what you might expect.

There are three scenarios:
* BATCHED console updates (i.e., with this commit applied).
* THOROUGH console updates, queuing to the EDT on every output event.
  (i.e., without this commit applied).
* NAIVE console updates, without queuing anything to the EDT at all.
  (i.e., w/o this commit or d86b605).

I ran three trials of SwingConsolePaneBenchmark for each of the
scenarios above. Here are the results (in ms) on my machine:
* BATCHED  = 158 159 154
* THOROUGH = 169 176 164
* NAIVE    = 999 716 735 (!!)

In all three cases, all output does eventually make it to the console,
and all the assertions in SwingConsolePaneBenchmark actually pass.
So at least on my system (OS X with Apple Java 1.6.0_65), it is not a
matter of correctness, only performance.

There is a downside to behavior with the BATCHED console updates though:
if the number of output events flood the queue faster than it can be
drained on the EDT, then the EDT will lock up indefinitely -- whereas
with the THOROUGH approach, at least you'll continue to see output on
the console, since the EDT gets freed up afterwards every time.

Author: ctrueden

src/main/java/org/scijava/ui/swing/console/SwingConsolePane.java

@@ -35,6 +35,7 @@
 import java.awt.Component;
 import java.awt.Dimension;
 import java.awt.Font;
+import java.util.concurrent.ConcurrentLinkedQueue;
 
 import javax.swing.JPanel;
 import javax.swing.JScrollPane;
@@ -81,6 +82,13 @@ public class SwingConsolePane extends AbstractConsolePane<JPanel> {
 	 */
 	private Component window;
 
+	/** Output queue, to avoid excessive queuing to the EDT. */
+	private ConcurrentLinkedQueue<OutputEvent> outputQueue =
+		new ConcurrentLinkedQueue<OutputEvent>();
+
+	/** Flag indicating that the EDT is currently flushing the output. */
+	private boolean outputFlushing;
+
 	public SwingConsolePane(final Context context) {
 		super(context);
 	}
@@ -107,19 +115,29 @@ public JScrollPane getScrollPane() {
 	@Override
 	public void append(final OutputEvent event) {
 		if (consolePanel == null) initConsolePanel();
+		outputQueue.add(event);
+		if (outputFlushing) return;
+		outputFlushing = true;
+
 		threadService.queue(new Runnable() {
 
 			@Override
 			public void run() {
-				final boolean atBottom =
-					StaticSwingUtils.isScrolledToBottom(scrollPane);
-				try {
-					doc.insertString(doc.getLength(), event.getOutput(), getStyle(event));
-				}
-				catch (final BadLocationException exc) {
-					throw new RuntimeException(exc);
+				while (true) {
+					outputFlushing = !outputQueue.isEmpty();
+					final OutputEvent item = outputQueue.poll();
+					if (item == null) break;
+
+					final boolean atBottom =
+						StaticSwingUtils.isScrolledToBottom(scrollPane);
+					try {
+						doc.insertString(doc.getLength(), item.getOutput(), getStyle(item));
+					}
+					catch (final BadLocationException exc) {
+						throw new RuntimeException(exc);
+					}
+					if (atBottom) StaticSwingUtils.scrollToBottom(scrollPane);
 				}
-				if (atBottom) StaticSwingUtils.scrollToBottom(scrollPane);
 			}
 		});
 	}