java查看当前项目所有线程列表界面【转】

java查看当前项目所有线程列表界面

1.TestThread(测试类)

package com.testdemo.pcis.isc.job.king.panel;

public class TestThread {
    public static void main(String[] args) {
        new Thread(){
            public void run() {
                try {
                    Thread.currentThread().sleep(10*1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };
        }.start();

        new Thread(){
            public void run() {
                try {
                    Thread.currentThread().sleep(20*1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };
        }.start();

        new Thread(){
            public void run() {
                try {
                    Thread.currentThread().sleep(30*1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };
        }.start();

        ThreadViewer.showThreads();
    }
}

2.ThreadViewer(线程视图启动类)

package com.testdemo.pcis.isc.job.king.panel;
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 showThreads() {
        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 ) {
            }
        }
    }  

    public static void main(String[] args) {
        showThreads();
    }
}  

3.ThreadViewerTableModel(线程视图编织类)

package com.isoftstone.pcis.isc.job.king.panel;
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(2000);
            } 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;
    }
}     

4运行前后比对

运行前界面

运行后界面

http://blog.csdn.net/daditao/article/details/19811669