获取Java VM中当前运行的所有线程

程序运行图：

   

下面的静态方法可以用数组返回Java VM中当前运行的所有线程
public static Thread[] findAllThreads() {
ThreadGroup group = 
Thread.currentThread().getThreadGroup();
ThreadGroup topGroup = group;

// 遍历线程组树，获取根线程组
while ( group != null ) {
topGroup = group;
group = group.getParent();
}
// 激活的线程数加倍
int estimatedSize = topGroup.activeCount() * 2;
Thread[] slackList = new Thread[estimatedSize];
//获取根线程组的所有线程
int actualSize = topGroup.enumerate(slackList);
// copy into a list that is the exact size
Thread[] list = new Thread[actualSize];
System.arraycopy(slackList, 0, list, 0, actualSize);
return list;
}

      程序ThreadViewer.java以图形方式显示Java VM中当前运行的所有线程,它每隔5秒自动刷新一次,以保持获得最新信息。

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.table.*;
public class ThreadViewer extends JPanel {
	private ThreadViewerTableModel tableModel;
	public ThreadViewer() {
		tableModel = new ThreadViewerTableModel();
		JTable table = new JTable(tableModel);
		table.setAutoResizeMode(JTable.AUTO_RESIZE_LAST_COLUMN);
		TableColumnModel colModel = table.getColumnModel();
		int numColumns = colModel.getColumnCount();
		// manually size all but the last column
		for ( int i = 0; i < numColumns - 1; i++ ) {
			TableColumn col = colModel.getColumn(i);
			col.sizeWidthToFit();
			col.setPreferredWidth(col.getWidth() + 5);
			col.setMaxWidth(col.getWidth() + 5);
		}
		JScrollPane sp = new JScrollPane(table);
		setLayout(new BorderLayout());
		add(sp, BorderLayout.CENTER);
	}
	public void dispose() {
		tableModel.stopRequest();
	}
	protected void finalize() throws Throwable {
		dispose();
	}
	public static JFrame createFramedInstance() {
		final ThreadViewer viewer = new ThreadViewer();
		final JFrame f = new JFrame("ThreadViewer");
		f.addWindowListener(new WindowAdapter() {
				public void windowClosing(WindowEvent e) {
					f.setVisible(false);
					f.dispose();
					viewer.dispose();
				}
			});
		f.setContentPane(viewer);
		f.setSize(500, 300);
		f.setVisible(true);
		return f;
	}
	
	public static void main(String[] args) {
		JFrame f = ThreadViewer.createFramedInstance();
		// For this example, exit the VM when the viewer
		// frame is closed.
		f.addWindowListener(new WindowAdapter() {
				public void windowClosing(WindowEvent e) {
					System.exit(0);
				}
			});
		// Keep the main thread from exiting by blocking
		// on wait() for a notification that never comes.
		Object lock = new Object();
		synchronized ( lock ) {
			try {
				lock.wait();
			} catch ( InterruptedException x ) {
			}
		}
	}
}

 

import java.awt.*;
import java.lang.reflect.*;
import javax.swing.*;
import javax.swing.table.*;
public class ThreadViewerTableModel extends AbstractTableModel {
	private Object dataLock; 
	private int rowCount;
	private Object[][] cellData;
	private Object[][] pendingCellData;
	// the column information remains constant
	private final int columnCount;
	private final String[] columnName;
	private final Class[] columnClass;
	// self-running object control variables
	private Thread internalThread;
	private volatile boolean noStopRequested;
	public ThreadViewerTableModel() {
		rowCount = 0;
		cellData = new Object[0][0];
		// JTable uses this information for the column headers
		String[] names = { 
			"Priority", "Alive", 
			"Daemon", "Interrupted", 
			"ThreadGroup", "Thread Name" };
		columnName = names;							
						
		// JTable uses this information for cell rendering
		Class[] classes = { 
			Integer.class, Boolean.class, 
			Boolean.class, Boolean.class, 
			String.class, String.class };
		columnClass = classes;
		columnCount = columnName.length;
		// used to control concurrent access
		dataLock = new Object(); 
		noStopRequested = true;
		Runnable r = new Runnable() {
				public void run() {
					try {
						runWork();
					} catch ( Exception x ) {
						// in case ANY exception slips through
						x.printStackTrace(); 
					}
				}
			};
		internalThread = new Thread(r, "ThreadViewer");
		internalThread.setPriority(Thread.MAX_PRIORITY - 2);
		internalThread.setDaemon(true);
		internalThread.start();
	}
	private void runWork() {
		// The run() method of transferPending is called by 
		// the event handling thread for safe concurrency.
		Runnable transferPending = new Runnable() {
				public void run() {
					transferPendingCellData();
					// Method of AbstractTableModel that 
					// causes the table to be updated.
					fireTableDataChanged(); 
				}
			};
		while ( noStopRequested ) {
			try {
				createPendingCellData();
				SwingUtilities.invokeAndWait(transferPending);
				Thread.sleep(5000);
			} catch ( InvocationTargetException tx ) {
				tx.printStackTrace();
				stopRequest();
			} catch ( InterruptedException x ) {
				Thread.currentThread().interrupt(); 
			}
		}
	}
	public void stopRequest() {
		noStopRequested = false;
		internalThread.interrupt();
	}
	public boolean isAlive() {
		return internalThread.isAlive();
	}
	private void createPendingCellData() {
		// this method is called by the internal thread
		Thread[] thread = findAllThreads();
		Object[][] cell = new Object[thread.length][columnCount];
		for ( int i = 0; i < thread.length; i++ ) {
			Thread t = thread[i];
			Object[] rowCell = cell[i];
			rowCell[0] = new Integer(t.getPriority());
			rowCell[1] = new Boolean(t.isAlive());
			rowCell[2] = new Boolean(t.isDaemon());
			rowCell[3] = new Boolean(t.isInterrupted());
			rowCell[4] = t.getThreadGroup().getName();
			rowCell[5] = t.getName();
		}
		synchronized ( dataLock ) {
			pendingCellData = cell;
		}
	}
	private void transferPendingCellData() {
		// this method is called by the event thread
		synchronized ( dataLock ) {
			cellData = pendingCellData;
			rowCount = cellData.length;
		}
	}
	public int getRowCount() {
		// this method is called by the event thread
		return rowCount;
	}
	
	public Object getValueAt(int row, int col) {
		// this method is called by the event thread
		return cellData[row][col];
	}
	public int getColumnCount() {
		return columnCount;
	}
	public Class getColumnClass(int columnIdx) {
		return columnClass[columnIdx];
	}
	public String getColumnName(int columnIdx) {
		return columnName[columnIdx];
	}
	public static Thread[] findAllThreads() {
		ThreadGroup group = 
			Thread.currentThread().getThreadGroup();
		ThreadGroup topGroup = group;
		// traverse the ThreadGroup tree to the top
		while ( group != null ) {
			topGroup = group;
			group = group.getParent();
		}
		// Create a destination array that is about
		// twice as big as needed to be very confident
		// that none are clipped.
		int estimatedSize = topGroup.activeCount() * 2;
		Thread[] slackList = new Thread[estimatedSize];
		// Load the thread references into the oversized
		// array. The actual number of threads loaded 
		// is returned.
		int actualSize = topGroup.enumerate(slackList);
		// copy into a list that is the exact size
		Thread[] list = new Thread[actualSize];
		System.arraycopy(slackList, 0, list, 0, actualSize);
		return list;
	}
}