java获取系统线程Thread信息

程序运行图：


    

下面的静态方法可以用数组返回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[]
4000
list = new Thread[actualSize];
System.arraycopy(slackList, 0, list, 0, actualSize);
return list;
}
}