Fixing crlfs

Project: http://git-wip-us.apache.org/repos/asf/commons-lang/repo
Commit: http://git-wip-us.apache.org/repos/asf/commons-lang/commit/69e97c8b
Tree: http://git-wip-us.apache.org/repos/asf/commons-lang/tree/69e97c8b
Diff: http://git-wip-us.apache.org/repos/asf/commons-lang/diff/69e97c8b

Branch: refs/heads/master
Commit: 69e97c8b42b9ad0880618132a613466f4e4779d3
Parents: a72a5ce
Author: Hen <h...@flamefew.com>
Authored: Thu Feb 25 20:52:13 2016 -0800
Committer: Hen <h...@flamefew.com>
Committed: Thu Feb 25 20:52:13 2016 -0800

----------------------------------------------------------------------
 .../org/apache/commons/lang3/ThreadUtils.java   |  920 ++---
 .../apache/commons/lang3/math/NumberUtils.java  | 3160 +++++++++---------
 2 files changed, 2040 insertions(+), 2040 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/commons-lang/blob/69e97c8b/src/main/java/org/apache/commons/lang3/ThreadUtils.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/lang3/ThreadUtils.java 
b/src/main/java/org/apache/commons/lang3/ThreadUtils.java
index 15f0c5c..89a59ce 100644
--- a/src/main/java/org/apache/commons/lang3/ThreadUtils.java
+++ b/src/main/java/org/apache/commons/lang3/ThreadUtils.java
@@ -1,460 +1,460 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.commons.lang3;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
-
-/**
- * <p>
- * Helpers for {@code java.lang.Thread} and {@code java.lang.ThreadGroup}.
- * </p>
- * <p>
- * #ThreadSafe#
- * </p>
- *
- * @see java.lang.Thread
- * @see java.lang.ThreadGroup
- * @since 3.5
- */
-public class ThreadUtils {
-
-    /**
-     * Return the active thread with the specified id if it belong's to the 
specified thread group.
-     *
-     * @param threadId The thread id
-     * @param threadGroup The thread group
-     * @return The thread which belongs to a specified thread group and the 
thread's id match the specified id.
-     * {@code null} is returned if no such thread exists
-     * @throws IllegalArgumentException if the specified id is zero or 
negative or the group is null
-     * @throws  SecurityException
-     *          if the current thread cannot access the system thread group
-     *
-     * @throws  SecurityException  if the current thread cannot modify
-     *          thread groups from this thread's thread group up to the system 
thread group
-     */
-    public static Thread findThreadById(final long threadId, final ThreadGroup 
threadGroup) {
-        if (threadGroup == null) {
-            throw new IllegalArgumentException("The thread group must not be 
null");
-        }
-        final Thread thread = findThreadById(threadId);
-        if(thread != null && threadGroup.equals(thread.getThreadGroup())) {
-            return thread;
-        }
-        return null;
-    }
-
-    /**
-     * Return the active thread with the specified id if it belong's to a 
thread group with the specified group name.
-     *
-     * @param threadId The thread id
-     * @param threadGroupName The thread group name
-     * @return The threads which belongs to a thread group with the specified 
group name and the thread's id match the specified id.
-     * {@code null} is returned if no such thread exists
-     * @throws IllegalArgumentException if the specified id is zero or 
negative or the group name is null
-     * @throws  SecurityException
-     *          if the current thread cannot access the system thread group
-     *
-     * @throws  SecurityException  if the current thread cannot modify
-     *          thread groups from this thread's thread group up to the system 
thread group
-     */
-    public static Thread findThreadById(final long threadId, final String 
threadGroupName) {
-        if (threadGroupName == null) {
-            throw new IllegalArgumentException("The thread group name must not 
be null");
-        }
-        final Thread thread = findThreadById(threadId);
-        if(thread != null && thread.getThreadGroup() != null && 
thread.getThreadGroup().getName().equals(threadGroupName)) {
-            return thread;
-        }
-        return null;
-    }
-
-    /**
-     * Return active threads with the specified name if they belong to a 
specified thread group.
-     *
-     * @param threadName The thread name
-     * @param threadGroup The thread group
-     * @return The threads which belongs to a thread group and the thread's 
name match the specified name,
-     * An empty collection is returned if no such thread exists. The 
collection returned is always unmodifiable.
-     * @throws IllegalArgumentException if the specified thread name or group 
is null
-     * @throws  SecurityException
-     *          if the current thread cannot access the system thread group
-     *
-     * @throws  SecurityException  if the current thread cannot modify
-     *          thread groups from this thread's thread group up to the system 
thread group
-     */
-    public static Collection<Thread> findThreadsByName(final String 
threadName, final ThreadGroup threadGroup) {
-        return findThreads(threadGroup, false, new NamePredicate(threadName));
-    }
-
-    /**
-     * Return active threads with the specified name if they belong to a 
thread group with the specified group name.
-     *
-     * @param threadName The thread name
-     * @param threadGroupName The thread group name
-     * @return The threads which belongs to a thread group with the specified 
group name and the thread's name match the specified name,
-     * An empty collection is returned if no such thread exists. The 
collection returned is always unmodifiable.
-     * @throws IllegalArgumentException if the specified thread name or group 
name is null
-     * @throws  SecurityException
-     *          if the current thread cannot access the system thread group
-     *
-     * @throws  SecurityException  if the current thread cannot modify
-     *          thread groups from this thread's thread group up to the system 
thread group
-     */
-    public static Collection<Thread> findThreadsByName(final String 
threadName, final String threadGroupName) {
-        if (threadName == null) {
-            throw new IllegalArgumentException("The thread name must not be 
null");
-        }
-        if (threadGroupName == null) {
-            throw new IllegalArgumentException("The thread group name must not 
be null");
-        }
-
-        final Collection<ThreadGroup> threadGroups = findThreadGroups(new 
NamePredicate(threadGroupName));
-
-        if(threadGroups.isEmpty()) {
-            return Collections.emptyList();
-        }
-
-        final Collection<Thread> result = new ArrayList<Thread>();
-        final NamePredicate threadNamePredicate = new 
NamePredicate(threadName);
-        for(final ThreadGroup group : threadGroups) {
-            result.addAll(findThreads(group, false, threadNamePredicate));
-        }
-        return Collections.unmodifiableCollection(result);
-    }
-
-    /**
-     * Return active thread groups with the specified group name.
-     *
-     * @param threadGroupName The thread group name
-     * @return the thread groups with the specified group name or an empty 
collection if no such thread group exists. The collection returned is always 
unmodifiable.
-     * @throws IllegalArgumentException if group name is null
-     * @throws  SecurityException
-     *          if the current thread cannot access the system thread group
-     *
-     * @throws  SecurityException  if the current thread cannot modify
-     *          thread groups from this thread's thread group up to the system 
thread group
-     */
-    public static Collection<ThreadGroup> findThreadGroupsByName(final String 
threadGroupName) {
-        return findThreadGroups(new NamePredicate(threadGroupName));
-    }
-
-    /**
-     * Return all active thread groups excluding the system thread group (A 
thread group is active if it has been not destroyed).
-     *
-     * @return all thread groups excluding the system thread group. The 
collection returned is always unmodifiable.
-     * @throws  SecurityException
-     *          if the current thread cannot access the system thread group
-     *
-     * @throws  SecurityException  if the current thread cannot modify
-     *          thread groups from this thread's thread group up to the system 
thread group
-     */
-    public static Collection<ThreadGroup> getAllThreadGroups() {
-        return findThreadGroups(ALWAYS_TRUE_PREDICATE);
-    }
-
-    /**
-     * Return the system thread group (sometimes also referred as "root thread 
group").
-     *
-     * @return the system thread group
-     * @throws  SecurityException  if the current thread cannot modify
-     *          thread groups from this thread's thread group up to the system 
thread group
-     */
-    public static ThreadGroup getSystemThreadGroup() {
-        ThreadGroup threadGroup = Thread.currentThread().getThreadGroup();
-        while(threadGroup.getParent() != null) {
-            threadGroup = threadGroup.getParent();
-        }
-        return threadGroup;
-    }
-
-    /**
-     * Return all active threads (A thread is active if it has been started 
and has not yet died).
-     *
-     * @return all active threads. The collection returned is always 
unmodifiable.
-     * @throws  SecurityException
-     *          if the current thread cannot access the system thread group
-     *
-     * @throws  SecurityException  if the current thread cannot modify
-     *          thread groups from this thread's thread group up to the system 
thread group
-     */
-    public static Collection<Thread> getAllThreads() {
-        return findThreads(ALWAYS_TRUE_PREDICATE);
-    }
-
-    /**
-     * Return active threads with the specified name.
-     *
-     * @param threadName The thread name
-     * @return The threads with the specified name or an empty collection if 
no such thread exists. The collection returned is always unmodifiable.
-     * @throws IllegalArgumentException if the specified name is null
-     * @throws  SecurityException
-     *          if the current thread cannot access the system thread group
-     *
-     * @throws  SecurityException  if the current thread cannot modify
-     *          thread groups from this thread's thread group up to the system 
thread group
-     */
-    public static Collection<Thread> findThreadsByName(final String 
threadName) {
-        return findThreads(new NamePredicate(threadName));
-    }
-
-    /**
-     * Return the active thread with the specified id.
-     *
-     * @param threadId The thread id
-     * @return The thread with the specified id or {@code null} if no such 
thread exists
-     * @throws IllegalArgumentException if the specified id is zero or negative
-     * @throws  SecurityException
-     *          if the current thread cannot access the system thread group
-     *
-     * @throws  SecurityException  if the current thread cannot modify
-     *          thread groups from this thread's thread group up to the system 
thread group
-     */
-    public static Thread findThreadById(final long threadId) {
-        final Collection<Thread> result = findThreads(new 
ThreadIdPredicate(threadId));
-        return result.isEmpty() ? null : result.iterator().next();
-    }
-
-    /**
-     * <p>
-     * ThreadUtils instances should NOT be constructed in standard 
programming. Instead, the class should be used as
-     * {@code ThreadUtils.getAllThreads()}
-     * </p>
-     * <p>
-     * This constructor is public to permit tools that require a JavaBean 
instance to operate.
-     * </p>
-     */
-    public ThreadUtils() {
-        super();
-    }
-
-    /**
-     * A predicate for selecting threads.
-     */
-    //if java minimal version for lang becomes 1.8 extend this interface from 
java.util.function.Predicate
-    public interface ThreadPredicate /*extends 
java.util.function.Predicate<Thread>*/{
-
-        /**
-         * Evaluates this predicate on the given thread.
-         * @param thread the thread
-         * @return {@code true} if the thread matches the predicate, otherwise 
{@code false}
-         */
-        boolean test(Thread thread);
-    }
-
-    /**
-     * A predicate for selecting threadgroups.
-     */
-    //if java minimal version for lang becomes 1.8 extend this interface from 
java.util.function.Predicate
-    public interface ThreadGroupPredicate /*extends 
java.util.function.Predicate<ThreadGroup>*/{
-
-        /**
-         * Evaluates this predicate on the given threadgroup.
-         * @param threadGroup the threadgroup
-         * @return {@code true} if the threadGroup matches the predicate, 
otherwise {@code false}
-         */
-        boolean test(ThreadGroup threadGroup);
-    }
-
-    /**
-     * Predicate which always returns true.
-     */
-    public static final AlwaysTruePredicate ALWAYS_TRUE_PREDICATE = new 
AlwaysTruePredicate();
-
-    /**
-     * A predicate implementation which always returns true.
-     */
-    private final static class AlwaysTruePredicate implements ThreadPredicate, 
ThreadGroupPredicate{
-
-        private AlwaysTruePredicate() {
-        }
-
-        @Override
-        public boolean test(final ThreadGroup threadGroup) {
-            return true;
-        }
-
-        @Override
-        public boolean test(final Thread thread) {
-            return true;
-        }
-    }
-
-    /**
-     * A predicate implementation which matches a thread or threadgroup name.
-     */
-    public static class NamePredicate implements ThreadPredicate, 
ThreadGroupPredicate {
-
-        private final String name;
-
-        /**
-         * Predicate constructor
-         *
-         * @param name thread or threadgroup name
-         * @throws IllegalArgumentException if the name is {@code null}
-         */
-        public NamePredicate(final String name) {
-            super();
-            if (name == null) {
-                throw new IllegalArgumentException("The name must not be 
null");
-            }
-            this.name = name;
-        }
-
-        @Override
-        public boolean test(final ThreadGroup threadGroup) {
-            return threadGroup != null && threadGroup.getName().equals(name);
-        }
-
-        @Override
-        public boolean test(final Thread thread) {
-            return thread != null && thread.getName().equals(name);
-        }
-    }
-
-    /**
-     * A predicate implementation which matches a thread id.
-     */
-    public static class ThreadIdPredicate implements ThreadPredicate {
-
-        private final long threadId;
-
-        /**
-         * Predicate constructor
-         *
-         * @param threadId the threadId to match
-         * @throws IllegalArgumentException if the threadId is zero or negative
-         */
-        public ThreadIdPredicate(final long threadId) {
-            super();
-            if (threadId <= 0) {
-                throw new IllegalArgumentException("The thread id must be 
greater than zero");
-            }
-            this.threadId = threadId;
-        }
-
-        @Override
-        public boolean test(final Thread thread) {
-            return thread != null && thread.getId() == threadId;
-        }
-    }
-
-    /**
-     * Select all active threads which match the given predicate.
-     *
-     * @param predicate the predicate
-     * @return An unmodifiable {@code Collection} of active threads matching 
the given predicate
-     *
-     * @throws IllegalArgumentException if the predicate is null
-     * @throws  SecurityException
-     *          if the current thread cannot access the system thread group
-     * @throws  SecurityException  if the current thread cannot modify
-     *          thread groups from this thread's thread group up to the system 
thread group
-     */
-    public static Collection<Thread> findThreads(final ThreadPredicate 
predicate){
-        return findThreads(getSystemThreadGroup(), true, predicate);
-    }
-
-    /**
-     * Select all active threadgroups which match the given predicate.
-     *
-     * @param predicate the predicate
-     * @return An unmodifiable {@code Collection} of active threadgroups 
matching the given predicate
-     * @throws IllegalArgumentException if the predicate is null
-     * @throws  SecurityException
-     *          if the current thread cannot access the system thread group
-     * @throws  SecurityException  if the current thread cannot modify
-     *          thread groups from this thread's thread group up to the system 
thread group
-     */
-    public static Collection<ThreadGroup> findThreadGroups(final 
ThreadGroupPredicate predicate){
-        return findThreadGroups(getSystemThreadGroup(), true, predicate);
-    }
-
-    /**
-     * Select all active threads which match the given predicate and which 
belongs to the given thread group (or one of its subgroups).
-     *
-     * @param group the thread group
-     * @param recurse if {@code true} then evaluate the predicate recursively 
on all threads in all subgroups of the given group
-     * @param predicate the predicate
-     * @return An unmodifiable {@code Collection} of active threads which 
match the given predicate and which belongs to the given thread group
-     * @throws IllegalArgumentException if the given group or predicate is null
-     * @throws  SecurityException  if the current thread cannot modify
-     *          thread groups from this thread's thread group up to the system 
thread group
-     */
-    public static Collection<Thread> findThreads(final ThreadGroup group, 
final boolean recurse, final ThreadPredicate predicate) {
-        if (group == null) {
-            throw new IllegalArgumentException("The group must not be null");
-        }
-        if (predicate == null) {
-            throw new IllegalArgumentException("The predicate must not be 
null");
-        }
-
-        int count = group.activeCount();
-        Thread[] threads;
-        do {
-            threads = new Thread[count + (count / 2) + 1]; //slightly grow the 
array size
-            count = group.enumerate(threads, recurse);
-            //return value of enumerate() must be strictly less than the array 
size according to javadoc
-        } while (count >= threads.length);
-
-        final List<Thread> result = new ArrayList<Thread>(count);
-        for (int i = 0; i < count; ++i) {
-            if (predicate.test(threads[i])) {
-                result.add(threads[i]);
-            }
-        }
-        return Collections.unmodifiableCollection(result);
-    }
-
-    /**
-     * Select all active threadgroups which match the given predicate and 
which is a subgroup of the given thread group (or one of its subgroups).
-     *
-     * @param group the thread group
-     * @param recurse if {@code true} then evaluate the predicate recursively 
on all threadgroups in all subgroups of the given group
-     * @param predicate the predicate
-     * @return An unmodifiable {@code Collection} of active threadgroups which 
match the given predicate and which is a subgroup of the given thread group
-     * @throws IllegalArgumentException if the given group or predicate is null
-     * @throws  SecurityException  if the current thread cannot modify
-     *          thread groups from this thread's thread group up to the system 
thread group
-     */
-    public static Collection<ThreadGroup> findThreadGroups(final ThreadGroup 
group, final boolean recurse, final ThreadGroupPredicate predicate){
-        if (group == null) {
-            throw new IllegalArgumentException("The group must not be null");
-        }
-        if (predicate == null) {
-            throw new IllegalArgumentException("The predicate must not be 
null");
-        }
-
-        int count = group.activeGroupCount();
-        ThreadGroup[] threadGroups;
-        do {
-            threadGroups = new ThreadGroup[count + (count / 2) + 1]; 
//slightly grow the array size
-            count = group.enumerate(threadGroups, recurse);
-            //return value of enumerate() must be strictly less than the array 
size according to javadoc
-        } while(count >= threadGroups.length);
-
-        final List<ThreadGroup> result = new ArrayList<ThreadGroup>(count);
-        for(int i = 0; i < count; ++i) {
-            if(predicate.test(threadGroups[i])) {
-                result.add(threadGroups[i]);
-            }
-        }
-        return Collections.unmodifiableCollection(result);
-    }
-}
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.lang3;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * <p>
+ * Helpers for {@code java.lang.Thread} and {@code java.lang.ThreadGroup}.
+ * </p>
+ * <p>
+ * #ThreadSafe#
+ * </p>
+ *
+ * @see java.lang.Thread
+ * @see java.lang.ThreadGroup
+ * @since 3.5
+ */
+public class ThreadUtils {
+
+    /**
+     * Return the active thread with the specified id if it belong's to the 
specified thread group.
+     *
+     * @param threadId The thread id
+     * @param threadGroup The thread group
+     * @return The thread which belongs to a specified thread group and the 
thread's id match the specified id.
+     * {@code null} is returned if no such thread exists
+     * @throws IllegalArgumentException if the specified id is zero or 
negative or the group is null
+     * @throws  SecurityException
+     *          if the current thread cannot access the system thread group
+     *
+     * @throws  SecurityException  if the current thread cannot modify
+     *          thread groups from this thread's thread group up to the system 
thread group
+     */
+    public static Thread findThreadById(final long threadId, final ThreadGroup 
threadGroup) {
+        if (threadGroup == null) {
+            throw new IllegalArgumentException("The thread group must not be 
null");
+        }
+        final Thread thread = findThreadById(threadId);
+        if(thread != null && threadGroup.equals(thread.getThreadGroup())) {
+            return thread;
+        }
+        return null;
+    }
+
+    /**
+     * Return the active thread with the specified id if it belong's to a 
thread group with the specified group name.
+     *
+     * @param threadId The thread id
+     * @param threadGroupName The thread group name
+     * @return The threads which belongs to a thread group with the specified 
group name and the thread's id match the specified id.
+     * {@code null} is returned if no such thread exists
+     * @throws IllegalArgumentException if the specified id is zero or 
negative or the group name is null
+     * @throws  SecurityException
+     *          if the current thread cannot access the system thread group
+     *
+     * @throws  SecurityException  if the current thread cannot modify
+     *          thread groups from this thread's thread group up to the system 
thread group
+     */
+    public static Thread findThreadById(final long threadId, final String 
threadGroupName) {
+        if (threadGroupName == null) {
+            throw new IllegalArgumentException("The thread group name must not 
be null");
+        }
+        final Thread thread = findThreadById(threadId);
+        if(thread != null && thread.getThreadGroup() != null && 
thread.getThreadGroup().getName().equals(threadGroupName)) {
+            return thread;
+        }
+        return null;
+    }
+
+    /**
+     * Return active threads with the specified name if they belong to a 
specified thread group.
+     *
+     * @param threadName The thread name
+     * @param threadGroup The thread group
+     * @return The threads which belongs to a thread group and the thread's 
name match the specified name,
+     * An empty collection is returned if no such thread exists. The 
collection returned is always unmodifiable.
+     * @throws IllegalArgumentException if the specified thread name or group 
is null
+     * @throws  SecurityException
+     *          if the current thread cannot access the system thread group
+     *
+     * @throws  SecurityException  if the current thread cannot modify
+     *          thread groups from this thread's thread group up to the system 
thread group
+     */
+    public static Collection<Thread> findThreadsByName(final String 
threadName, final ThreadGroup threadGroup) {
+        return findThreads(threadGroup, false, new NamePredicate(threadName));
+    }
+
+    /**
+     * Return active threads with the specified name if they belong to a 
thread group with the specified group name.
+     *
+     * @param threadName The thread name
+     * @param threadGroupName The thread group name
+     * @return The threads which belongs to a thread group with the specified 
group name and the thread's name match the specified name,
+     * An empty collection is returned if no such thread exists. The 
collection returned is always unmodifiable.
+     * @throws IllegalArgumentException if the specified thread name or group 
name is null
+     * @throws  SecurityException
+     *          if the current thread cannot access the system thread group
+     *
+     * @throws  SecurityException  if the current thread cannot modify
+     *          thread groups from this thread's thread group up to the system 
thread group
+     */
+    public static Collection<Thread> findThreadsByName(final String 
threadName, final String threadGroupName) {
+        if (threadName == null) {
+            throw new IllegalArgumentException("The thread name must not be 
null");
+        }
+        if (threadGroupName == null) {
+            throw new IllegalArgumentException("The thread group name must not 
be null");
+        }
+
+        final Collection<ThreadGroup> threadGroups = findThreadGroups(new 
NamePredicate(threadGroupName));
+
+        if(threadGroups.isEmpty()) {
+            return Collections.emptyList();
+        }
+
+        final Collection<Thread> result = new ArrayList<Thread>();
+        final NamePredicate threadNamePredicate = new 
NamePredicate(threadName);
+        for(final ThreadGroup group : threadGroups) {
+            result.addAll(findThreads(group, false, threadNamePredicate));
+        }
+        return Collections.unmodifiableCollection(result);
+    }
+
+    /**
+     * Return active thread groups with the specified group name.
+     *
+     * @param threadGroupName The thread group name
+     * @return the thread groups with the specified group name or an empty 
collection if no such thread group exists. The collection returned is always 
unmodifiable.
+     * @throws IllegalArgumentException if group name is null
+     * @throws  SecurityException
+     *          if the current thread cannot access the system thread group
+     *
+     * @throws  SecurityException  if the current thread cannot modify
+     *          thread groups from this thread's thread group up to the system 
thread group
+     */
+    public static Collection<ThreadGroup> findThreadGroupsByName(final String 
threadGroupName) {
+        return findThreadGroups(new NamePredicate(threadGroupName));
+    }
+
+    /**
+     * Return all active thread groups excluding the system thread group (A 
thread group is active if it has been not destroyed).
+     *
+     * @return all thread groups excluding the system thread group. The 
collection returned is always unmodifiable.
+     * @throws  SecurityException
+     *          if the current thread cannot access the system thread group
+     *
+     * @throws  SecurityException  if the current thread cannot modify
+     *          thread groups from this thread's thread group up to the system 
thread group
+     */
+    public static Collection<ThreadGroup> getAllThreadGroups() {
+        return findThreadGroups(ALWAYS_TRUE_PREDICATE);
+    }
+
+    /**
+     * Return the system thread group (sometimes also referred as "root thread 
group").
+     *
+     * @return the system thread group
+     * @throws  SecurityException  if the current thread cannot modify
+     *          thread groups from this thread's thread group up to the system 
thread group
+     */
+    public static ThreadGroup getSystemThreadGroup() {
+        ThreadGroup threadGroup = Thread.currentThread().getThreadGroup();
+        while(threadGroup.getParent() != null) {
+            threadGroup = threadGroup.getParent();
+        }
+        return threadGroup;
+    }
+
+    /**
+     * Return all active threads (A thread is active if it has been started 
and has not yet died).
+     *
+     * @return all active threads. The collection returned is always 
unmodifiable.
+     * @throws  SecurityException
+     *          if the current thread cannot access the system thread group
+     *
+     * @throws  SecurityException  if the current thread cannot modify
+     *          thread groups from this thread's thread group up to the system 
thread group
+     */
+    public static Collection<Thread> getAllThreads() {
+        return findThreads(ALWAYS_TRUE_PREDICATE);
+    }
+
+    /**
+     * Return active threads with the specified name.
+     *
+     * @param threadName The thread name
+     * @return The threads with the specified name or an empty collection if 
no such thread exists. The collection returned is always unmodifiable.
+     * @throws IllegalArgumentException if the specified name is null
+     * @throws  SecurityException
+     *          if the current thread cannot access the system thread group
+     *
+     * @throws  SecurityException  if the current thread cannot modify
+     *          thread groups from this thread's thread group up to the system 
thread group
+     */
+    public static Collection<Thread> findThreadsByName(final String 
threadName) {
+        return findThreads(new NamePredicate(threadName));
+    }
+
+    /**
+     * Return the active thread with the specified id.
+     *
+     * @param threadId The thread id
+     * @return The thread with the specified id or {@code null} if no such 
thread exists
+     * @throws IllegalArgumentException if the specified id is zero or negative
+     * @throws  SecurityException
+     *          if the current thread cannot access the system thread group
+     *
+     * @throws  SecurityException  if the current thread cannot modify
+     *          thread groups from this thread's thread group up to the system 
thread group
+     */
+    public static Thread findThreadById(final long threadId) {
+        final Collection<Thread> result = findThreads(new 
ThreadIdPredicate(threadId));
+        return result.isEmpty() ? null : result.iterator().next();
+    }
+
+    /**
+     * <p>
+     * ThreadUtils instances should NOT be constructed in standard 
programming. Instead, the class should be used as
+     * {@code ThreadUtils.getAllThreads()}
+     * </p>
+     * <p>
+     * This constructor is public to permit tools that require a JavaBean 
instance to operate.
+     * </p>
+     */
+    public ThreadUtils() {
+        super();
+    }
+
+    /**
+     * A predicate for selecting threads.
+     */
+    //if java minimal version for lang becomes 1.8 extend this interface from 
java.util.function.Predicate
+    public interface ThreadPredicate /*extends 
java.util.function.Predicate<Thread>*/{
+
+        /**
+         * Evaluates this predicate on the given thread.
+         * @param thread the thread
+         * @return {@code true} if the thread matches the predicate, otherwise 
{@code false}
+         */
+        boolean test(Thread thread);
+    }
+
+    /**
+     * A predicate for selecting threadgroups.
+     */
+    //if java minimal version for lang becomes 1.8 extend this interface from 
java.util.function.Predicate
+    public interface ThreadGroupPredicate /*extends 
java.util.function.Predicate<ThreadGroup>*/{
+
+        /**
+         * Evaluates this predicate on the given threadgroup.
+         * @param threadGroup the threadgroup
+         * @return {@code true} if the threadGroup matches the predicate, 
otherwise {@code false}
+         */
+        boolean test(ThreadGroup threadGroup);
+    }
+
+    /**
+     * Predicate which always returns true.
+     */
+    public static final AlwaysTruePredicate ALWAYS_TRUE_PREDICATE = new 
AlwaysTruePredicate();
+
+    /**
+     * A predicate implementation which always returns true.
+     */
+    private final static class AlwaysTruePredicate implements ThreadPredicate, 
ThreadGroupPredicate{
+
+        private AlwaysTruePredicate() {
+        }
+
+        @Override
+        public boolean test(final ThreadGroup threadGroup) {
+            return true;
+        }
+
+        @Override
+        public boolean test(final Thread thread) {
+            return true;
+        }
+    }
+
+    /**
+     * A predicate implementation which matches a thread or threadgroup name.
+     */
+    public static class NamePredicate implements ThreadPredicate, 
ThreadGroupPredicate {
+
+        private final String name;
+
+        /**
+         * Predicate constructor
+         *
+         * @param name thread or threadgroup name
+         * @throws IllegalArgumentException if the name is {@code null}
+         */
+        public NamePredicate(final String name) {
+            super();
+            if (name == null) {
+                throw new IllegalArgumentException("The name must not be 
null");
+            }
+            this.name = name;
+        }
+
+        @Override
+        public boolean test(final ThreadGroup threadGroup) {
+            return threadGroup != null && threadGroup.getName().equals(name);
+        }
+
+        @Override
+        public boolean test(final Thread thread) {
+            return thread != null && thread.getName().equals(name);
+        }
+    }
+
+    /**
+     * A predicate implementation which matches a thread id.
+     */
+    public static class ThreadIdPredicate implements ThreadPredicate {
+
+        private final long threadId;
+
+        /**
+         * Predicate constructor
+         *
+         * @param threadId the threadId to match
+         * @throws IllegalArgumentException if the threadId is zero or negative
+         */
+        public ThreadIdPredicate(final long threadId) {
+            super();
+            if (threadId <= 0) {
+                throw new IllegalArgumentException("The thread id must be 
greater than zero");
+            }
+            this.threadId = threadId;
+        }
+
+        @Override
+        public boolean test(final Thread thread) {
+            return thread != null && thread.getId() == threadId;
+        }
+    }
+
+    /**
+     * Select all active threads which match the given predicate.
+     *
+     * @param predicate the predicate
+     * @return An unmodifiable {@code Collection} of active threads matching 
the given predicate
+     *
+     * @throws IllegalArgumentException if the predicate is null
+     * @throws  SecurityException
+     *          if the current thread cannot access the system thread group
+     * @throws  SecurityException  if the current thread cannot modify
+     *          thread groups from this thread's thread group up to the system 
thread group
+     */
+    public static Collection<Thread> findThreads(final ThreadPredicate 
predicate){
+        return findThreads(getSystemThreadGroup(), true, predicate);
+    }
+
+    /**
+     * Select all active threadgroups which match the given predicate.
+     *
+     * @param predicate the predicate
+     * @return An unmodifiable {@code Collection} of active threadgroups 
matching the given predicate
+     * @throws IllegalArgumentException if the predicate is null
+     * @throws  SecurityException
+     *          if the current thread cannot access the system thread group
+     * @throws  SecurityException  if the current thread cannot modify
+     *          thread groups from this thread's thread group up to the system 
thread group
+     */
+    public static Collection<ThreadGroup> findThreadGroups(final 
ThreadGroupPredicate predicate){
+        return findThreadGroups(getSystemThreadGroup(), true, predicate);
+    }
+
+    /**
+     * Select all active threads which match the given predicate and which 
belongs to the given thread group (or one of its subgroups).
+     *
+     * @param group the thread group
+     * @param recurse if {@code true} then evaluate the predicate recursively 
on all threads in all subgroups of the given group
+     * @param predicate the predicate
+     * @return An unmodifiable {@code Collection} of active threads which 
match the given predicate and which belongs to the given thread group
+     * @throws IllegalArgumentException if the given group or predicate is null
+     * @throws  SecurityException  if the current thread cannot modify
+     *          thread groups from this thread's thread group up to the system 
thread group
+     */
+    public static Collection<Thread> findThreads(final ThreadGroup group, 
final boolean recurse, final ThreadPredicate predicate) {
+        if (group == null) {
+            throw new IllegalArgumentException("The group must not be null");
+        }
+        if (predicate == null) {
+            throw new IllegalArgumentException("The predicate must not be 
null");
+        }
+
+        int count = group.activeCount();
+        Thread[] threads;
+        do {
+            threads = new Thread[count + (count / 2) + 1]; //slightly grow the 
array size
+            count = group.enumerate(threads, recurse);
+            //return value of enumerate() must be strictly less than the array 
size according to javadoc
+        } while (count >= threads.length);
+
+        final List<Thread> result = new ArrayList<Thread>(count);
+        for (int i = 0; i < count; ++i) {
+            if (predicate.test(threads[i])) {
+                result.add(threads[i]);
+            }
+        }
+        return Collections.unmodifiableCollection(result);
+    }
+
+    /**
+     * Select all active threadgroups which match the given predicate and 
which is a subgroup of the given thread group (or one of its subgroups).
+     *
+     * @param group the thread group
+     * @param recurse if {@code true} then evaluate the predicate recursively 
on all threadgroups in all subgroups of the given group
+     * @param predicate the predicate
+     * @return An unmodifiable {@code Collection} of active threadgroups which 
match the given predicate and which is a subgroup of the given thread group
+     * @throws IllegalArgumentException if the given group or predicate is null
+     * @throws  SecurityException  if the current thread cannot modify
+     *          thread groups from this thread's thread group up to the system 
thread group
+     */
+    public static Collection<ThreadGroup> findThreadGroups(final ThreadGroup 
group, final boolean recurse, final ThreadGroupPredicate predicate){
+        if (group == null) {
+            throw new IllegalArgumentException("The group must not be null");
+        }
+        if (predicate == null) {
+            throw new IllegalArgumentException("The predicate must not be 
null");
+        }
+
+        int count = group.activeGroupCount();
+        ThreadGroup[] threadGroups;
+        do {
+            threadGroups = new ThreadGroup[count + (count / 2) + 1]; 
//slightly grow the array size
+            count = group.enumerate(threadGroups, recurse);
+            //return value of enumerate() must be strictly less than the array 
size according to javadoc
+        } while(count >= threadGroups.length);
+
+        final List<ThreadGroup> result = new ArrayList<ThreadGroup>(count);
+        for(int i = 0; i < count; ++i) {
+            if(predicate.test(threadGroups[i])) {
+                result.add(threadGroups[i]);
+            }
+        }
+        return Collections.unmodifiableCollection(result);
+    }
+}

Reply via email to