Board logo

标题: java 如何根据线程id找到线程 [打印本页]

作者: yuyang911220    时间: 2017-1-25 20:20     标题: java 如何根据线程id找到线程

Java代码  收藏代码
    /**
     * Copyright 2008, David Robert Nadeau, NadeauSoftware.com
     *
     * This file is free software: you can redistribute it and/or modify
     * it under the terms of the GNU Lesser General Public License as
     * published by the Free Software Foundation, either version 2 of
     * the License, or (at your option) any later version.
     *
     * This file is distributed in the hope that it will be useful,
     * but WITHOUT ANY WARRANTY; without even the implied warranty of
     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     * GNU Lesser General Public License for more details.
     *
     * You should have received a copy of the GNU Lesser General Public
     * License along with this file.  If not, see
     * <a href="http://www.gnu.org/licenses">GNU Licenses</a>.
     */  
      
    import java.lang.management.*;  
      
    /**
     * The ThreadUtilities class provides a collection of static methods
     * for listing and finding Thread, ThreadGroup, and ThreadInfo objects.
     * <p>
     * Please see the accompanying article:
     * <a href="http://nadeausoftware.com/articles/2008/04/java_tip_how_list_and_find_threads_and_thread_groups">Java tip:  How to list and find threads and thread groups</a>
     *
     * @author  <a href="http://NadeauSoftware.com/">David R. Nadeau</a>
     */  
    public final class ThreadUtilities  
    {  
    // Dummy constructor  
        /**
         * The ThreadUtilities class cannot be instanced.
         */  
        private ThreadUtilities( )  
        {  
        }  
      
      
      
      
      
    // Thread groups  
        /**
         * The root thread group saved on the first search for it.
         * The root group doesn't change for the life of the JVM,
         * so once found there is no need to find it again.
         */  
        private static ThreadGroup rootThreadGroup = null;  
      
        /**
         * Get the root thread group in the thread group tree.
         * Since there is always a root thread group, this
         * method never returns null.
         *
         * @return      the root thread group
         */  
        public static ThreadGroup getRootThreadGroup( )  
        {  
            if ( rootThreadGroup != null )  
                return rootThreadGroup;  
      
            ThreadGroup tg = Thread.currentThread( ).getThreadGroup( );  
            ThreadGroup ptg;  
            while ( (ptg = tg.getParent( )) != null )  
                tg = ptg;  
            rootThreadGroup = tg;  
            return tg;  
        }  
      
        /**
         * Get a list of all thread groups.  Since there is
         * always at least one thread group (the root), this
         * method never returns a null or empty array.
         *
         * @return      an array of thread groups
         */  
        public static ThreadGroup[] getAllThreadGroups( )  
        {  
            final ThreadGroup root = getRootThreadGroup( );  
            int nAlloc = root.activeGroupCount( );  
            int n = 0;  
            ThreadGroup[] groups = null;  
            do  
            {  
                nAlloc *= 2;  
                groups = new ThreadGroup[ nAlloc ];  
                n = root.enumerate( groups, true );  
            } while ( n == nAlloc );  
            ThreadGroup[] allGroups = new ThreadGroup[n+1];  
            allGroups[0] = root;  
            System.arraycopy( groups, 0, allGroups, 1, n );  
            return allGroups;  
        }  
      
        /**
         * Get the thread group with the given name.  A null is
         * returned if no such group is found.  If more than one
         * group has the same name, the first one found is returned.
         *
         * @param   name    the thread group name to search for
         * @return      the thread group, or null if not found
         * @throws  NullPointerException
         *          if the name is null
         */  
        public static ThreadGroup getThreadGroup( final String name )  
        {  
            if ( name == null )  
                throw new NullPointerException( "Null name" );  
            final ThreadGroup[] groups = getAllThreadGroups( );  
            for ( ThreadGroup group : groups )  
                if ( group.getName( ).equals( name ) )  
                    return group;  
            return null;  
        }  
      
      
      
      
      
    // Threads  
        /**
         * Get a list of all threads.  Since there is always at
         * least one thread, this method never returns null or
         * an empty array.
         *
         * @return      an array of threads
         */  
        public static Thread[] getAllThreads( )  
        {  
            final ThreadGroup root = getRootThreadGroup( );  
            final ThreadMXBean thbean =  
                ManagementFactory.getThreadMXBean( );  
            int nAlloc = thbean.getThreadCount( );  
            int n = 0;  
            Thread[] threads = null;  
            do  
            {  
                nAlloc *= 2;  
                threads = new Thread[ nAlloc ];  
                n = root.enumerate( threads, true );  
            } while ( n == nAlloc );  
            return java.util.Arrays.copyOf( threads, n );  
        }  
      
        /**
         * Get a list of all threads in a thread group.  An empty
         * array is returned if there are no threads in the group.
         *
         * @param   group   the thread group to list
         * @return      an array of threads
         * @throws  NullPointerException
         *          if the group is null
         */  
        public static Thread[] getGroupThreads( final ThreadGroup group )  
        {  
            if ( group == null )  
                throw new NullPointerException( "Null group" );  
            int nAlloc = group.activeCount( );  
            int n = 0;  
            Thread[] threads = null;  
            do  
            {  
                nAlloc *= 2;  
                threads = new Thread[ nAlloc ];  
                n = group.enumerate( threads, false );  
            } while ( n == nAlloc );  
            return java.util.Arrays.copyOf( threads, n );  
        }  
      
        /**
         * Get a list of all threads in a named thread group.
         * A null is returned if the group cannot be found.
         * An empty array is returned if there are no threads in
         * the group.
         *
         * @param   name    the name of the thread group
         * @return      an array of threads, or null if the
         *          group is not found
         * @throws  NullPointerException
         *          if the name is null
         */  
        public static Thread[] getGroupThreads( final String name )  
        {  
            final ThreadGroup group = getThreadGroup( name );  
            if ( group == null )  
                return null;  
            return getGroupThreads( group );  
        }  
      
        /**
         * Get a list of all threads, sorted from highest to
         * lowest priority.  Since there is always at least one
         * thread, this method never returns null or an empty
         * array.  Since threads may change their priority during
         * this method's sort, the returned thread list may not be
         * correct by the time it is returned.
         *
         * @return      an array of threads
         */  
        public static Thread[] getAllThreadsPrioritized( )  
        {  
            final Thread[] allThreads = getAllThreads( );  
            java.util.Arrays.sort( allThreads,  
            new java.util.Comparator<Thread>( )  
            {  
                public int compare( final Thread t1, final Thread t2 )  
                { return t2.getPriority( ) - t1.getPriority( ); }  
            } );  
            return allThreads;  
        }




欢迎光临 电子技术论坛_中国专业的电子工程师学习交流社区-中电网技术论坛 (http://bbs.eccn.com/) Powered by Discuz! 7.0.0