Blue Walrus

A lot of Swing tutorials on the internet focus on SwingWorkers and dealing
with a single thread running concurrently to the Event Dispatch Thread (EDT). This tutorial is going
to look at some more tricky techniques and traps that one might encounter
when dealing with numerous threads updating the GUI.

In this tutorial we will assume that we want a table that displays a number
of rows. Behind each of these rows a process should exist which will be updated by
some background thread, and we want to reflect these updates in the table. In
effect we are dealing with x-number of threads running in the background and
updating x-number of cells in a JTable.

screen example :

Part 1. Create the Swing Application First

Firstly lets assume we have some simple bean called Process. This entity will characterise the process that we will be dealing with.

Process.java.

	class Process {

		public Process(String name, int progress, String description) {
			super();
			this.name = name;
			this.progress = progress;
			this.description = description;
		}

		String name;
		int progress;
		String description;
	}

We want this process to have its progress value updated by some
background thread. In our example we want our process updated in random increments to 100.

Now lets create a table model for our JTable, which will display these process entities.

ProcessTableModel.java.

	private ArrayList processList = new ArrayList();

	class ProcessTableModel extends AbstractTableModel {

		private String[] columnNames;

		public ProcessTableModel() {

			columnNames = new String[] {"Process", "Progress", ""};
			for (int i = 0; i < 200; i++) {
				processList.add(new Process("Process " + i, 0, "Description"));
			}
		}

		public Process getProcessAt(int row2) {
			return processList.get(row2);
		}

		public int getColumnCount() {
			return columnNames.length;
		}

		public int getRowCount() {
			return 200;
		}

		public String getColumnName(int col) {
			return columnNames[col];
		}

		public Object getValueAt(int row, int col) {

			Process p = processList.get(row);

			switch (col) {
			case 0:
				return p.name;
			case 1:
				return p.progress;
			case 2:
				return "";
			}
			return "";
		}

		public Class getColumnClass(int c) {
			return getValueAt(0, c).getClass();
		}
	}

There is nothing unusual about this table model. We are creating 200
instances of Process and adding them to the internal arraylist for this table
model. The internal arraylist in this code example is shown as external because we would like to have this table model as an inner class.

Our renderer for the progress column is going to look a bit more interesting.
We are going to use a JProgressBar to render the 0 to 100 value inside each
Process bean. Since table renderers can return JComponents this is a
perfectly acceptable way of rendering a value.

ProcessProgressRenderer.java:

	class ProgressRenderer extends DefaultTableCellRenderer {
		public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected,
				boolean hasFocus, int row2, int column) {

			int row = table.convertRowIndexToModel(row2);

			ProcessTableModel mtm = (ProcessTableModel) table.getModel();
			Process p = (Process) mtm.getProcessAt(row);

			JProgressBar bar = new JProgressBar();
			bar.setValue(p.progress);
			return bar;
		}
	}

Lets create a basic GUI where we can put this table into, along with a button
which will fire off all the processes displayed in the table.

ThreadGUITest.java :

	public static void main(String[] args) {
		new ThreadGUITest().initGUI();
	}

	private void initGUI() {

		JPanel panel = new JPanel();

		ProcessTableModel m = new ProcessTableModel();

		table = new JTable(m);
		panel.add(new JScrollPane(table));

		table.getColumnModel().getColumn(1).setCellRenderer(new ProgressRenderer());

		JFrame mainFrame = new JFrame();
		startAllButton.addActionListener(this);
		mainFrame.getContentPane().add(panel, BorderLayout.NORTH);
		mainFrame.getContentPane().add(startAllButton);

		mainFrame.setVisible(true);
		mainFrame.pack();
	}

Part 2. Start Creating the Multithreading Aspect

Now lets get the thread magic happening. After the use clicks the ‘start all’ button,
each process will be fired off. The process itself will not actually be fired off (it is not a thread), however a wrapper class will handle the threading for the process entity. (Note : it is important not to make entities threads. Delegate this responsibility to a facade or proxy)

After the thread is fired off, the progress value will be re calculated.

ProgressUpdator.java

	class ProgressUpdater implements Runnable {

		private int row;

		public ProgressUpdater(int row) {
			this.row = row;
		}

		public void run() {

			final Process pr = processList.get(row);

			Random random = new Random();
			int progress = 0;

			// Initialize progress property.
			pr.progress = 0;

			while (progress < 100) {

				// Sleep for up to one second.
				try {

					Thread.sleep(random.nextInt(1000));

				} catch (InterruptedException ignore) {
				}
				// get random progress number
				progress = progress + random.nextInt(10);

				final int p = progress;

				pr.progress = Math.min(p, 100);

				ProcessTableModel m = (ProcessTableModel) table.getModel();

				m.fireTableCellUpdated(row, 1);
			}
		}
	}

The fireTableCellUpdated(row, 1) method on the table model, notifies the
event dispatch thread to re-render that particular cell in the JTable. It is possible to use the method updateTableModel() from the table model class, which would update every cell in the JTable, however this would be more performance intensive and unnecessary in our case.

Each one of these ProgressUpdaters (threads per se) will access one of the process
elements in the arraylist, hence the reason we are passing a row number into
the constructor. The row number is what links the ProgressUpdater with the Process.

Let’s add an Actionlistener to the button. On clicking the ‘start-all’ button all threads
will be fired off.

public void actionPerformed(ActionEvent evt) {
  startAllButton.setEnabled(false);

  for (ProgressUpdater elem : progressUpdaters) { Thread t = new Thread(elem);
  t.start(); }
}

Run the GUI. Pretty cool huh? But there is something missing. When all the
processes have finished the start all button still remains disabled. We would
like to know when all the processes have finished, so that we can re-enable the button.

We could use
Thread.join(). The thread join() method joins the calling thread to the main thread, effectively freezing the main thread until all joined threads
have run to completion. We could join all the threads in the
actionPerformed(..) method, and once they have run to completion we could set
the button to enabled again.

A valid assumption would be to change the actionPerformed method like this :

public void actionPerformed(ActionEvent evt) {
  	startAllButton.setEnabled(false);

  	ArrayList<Thread> threads = new ArrayList<Thread>();

  	for (ProgressUpdater elem : progressUpdaters) {
  		Thread t = new Thread(elem);
  		threads.add(t);
  		t.start();
  	}

  	for (Thread elem : threads) {
  		try {
  			elem.join();
  		} catch (InterruptedException e) {
  			// TODO Auto-generated catch block
  			e.printStackTrace();
  		}
  	}

  	startAllButton.setEnabled(true);

  }

But now when we run our program, everything freezes. Whats going on? Why
can’t we fire off all our threads in the actionPerformed method and have them
all joined within this method? Once the threads have finished running,
why can’t we then update any GUI code?

The reason is that we are blocking the event dispatch thread. Nothing can
happen to the GUI while all the threads are running to completion. They are
not joined to the main thread, rather they are joined to the EDT.

We need to solve this by having all the threads joined on another thread. All
we have to do is take out all the thread code in the actionPerformed(..)
method and fire off that thread, leaving the EDT alone.

Create a thread and put the code in it like this :

	class MainThread extends Thread {

		public void run() {
			ArrayList ts = new ArrayList();

			for (ProgressUpdater pu : progressUpdaters) {

				Thread t = new Thread(pu);
				ts.add(t);
				try {
					t.start();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}

			/**
			 * We need to join the threads after they all have been started.
			 */
			for (Thread pu : ts) {

				try {
					pu.join();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}

			SwingUtilities.invokeLater(new Runnable() {

				public void run() {
					startAllButton.setEnabled(true);
				}
			});
		}
	}

Now we can fire off this thread in the actionPerformed(..) method. After completion of all the processes the button will be enabled again!

Hope you enjoy and please leave a comment.

Full source code :

package tableWithProgressBar.temp;

import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Random;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JProgressBar;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.SwingUtilities;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.DefaultTableCellRenderer;

public class ThreadGUITest implements ActionListener {

	private JTable table;

	private JButton startAllButton = new JButton("Start");

	private ArrayList processList = new ArrayList();

	private ArrayList progressUpdaters = new ArrayList();

	public ThreadGUITest() {

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

			ProgressUpdater pu = new ProgressUpdater(i);
			progressUpdaters.add(pu);
		}
	}

	public static void main(String[] args) {
		new ThreadGUITest().initGUI();
	}

	private void initGUI() {

		JPanel panel = new JPanel();

		ProcessTableModel m = new ProcessTableModel();

		table = new JTable(m);
		panel.add(new JScrollPane(table));

		table.getColumnModel().getColumn(1).setCellRenderer(new ProgressRenderer());

		JFrame mainFrame = new JFrame();
		startAllButton.addActionListener(this);
		mainFrame.getContentPane().add(panel, BorderLayout.NORTH);
		mainFrame.getContentPane().add(startAllButton);

		mainFrame.setVisible(true);
		mainFrame.pack();
	}

	/**
	 * Invoked when the user presses the start button.
	 */
	public void actionPerformed(ActionEvent evt) {
		startAllButton.setEnabled(false);

		MainThread mt = new MainThread();
		mt.start();
	}

	class MainThread extends Thread {

		public void run() {
			ArrayList ts = new ArrayList();

			for (ProgressUpdater pu : progressUpdaters) {

				Thread t = new Thread(pu);
				ts.add(t);
				try {
					t.start();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}

			/**
			 * We need to join the threads after they all have been started.
			 */
			for (Thread pu : ts) {

				try {
					pu.join();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}

			System.out.println("here");
			SwingUtilities.invokeLater(new Runnable() {

				public void run() {
					startAllButton.setEnabled(true);
				}
			});
		}
	}

	/**
	 * The responsibiliey of the progress updater is to update the progress of its process
	 * (linked via the row number).
	 */
	class ProgressUpdater implements Runnable {

		private int row;

		public ProgressUpdater(int row) {
			this.row = row;
		}

		public void run() {

			final Process pr = processList.get(row);

			Random random = new Random();
			int progress = 0;

			// Initialize progress property.
			pr.progress = 0;

			while (progress < 100) {

				// Sleep for up to one second.
				try {

					Thread.sleep(random.nextInt(1000));

				} catch (InterruptedException ignore) {
				}
				// get random progress number
				progress = progress + random.nextInt(10);

				final int p = progress;

				pr.progress = Math.min(p, 100);

				ProcessTableModel m = (ProcessTableModel) table.getModel();

				m.fireTableCellUpdated(row, 1);
			}
		}
	}

	class ProgressRenderer extends DefaultTableCellRenderer {
		public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected,
				boolean hasFocus, int row2, int column) {

			int row = table.convertRowIndexToModel(row2);

			ProcessTableModel mtm = (ProcessTableModel) table.getModel();
			Process p = (Process) mtm.getProcessAt(row);

			JProgressBar bar = new JProgressBar();
			bar.setValue(p.progress);
			return bar;
		}
	}

	class Process {

		public Process(String name, int progress, String description) {
			super();
			this.name = name;
			this.progress = progress;
			this.description = description;
		}

		String name;
		int progress;
		String description;
	}

	class ProcessTableModel extends AbstractTableModel {

		private String[] columnNames;

		public ProcessTableModel() {

			columnNames = new String[] {"Process", "Progress", ""};

			for (int i = 0; i < 200; i++) {
				processList.add(new Process("Process " + i, 0, "Description"));
			}
		}

		public Process getProcessAt(int row2) {
			return processList.get(row2);
		}

		public int getColumnCount() {
			return columnNames.length;
		}

		public int getRowCount() {
			return 200;
		}

		public String getColumnName(int col) {
			return columnNames[col];
		}

		public Object getValueAt(int row, int col) {

			Process p = processList.get(row);

			switch (col) {
			case 0:
				return p.name;
			case 1:
				return p.progress;
			case 2:
				return "";
			}
			return "";
		}

		public Class getColumnClass(int c) {
			return getValueAt(0, c).getClass();
		}
	}

}