Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
Apache Commons Lang v3 Source Code Files
Apache Commons Lang 3 is the 3rd version of Apache Commons Lang, which provides a host of helper utilities for the java.lang API.
Apache Commons Lang 3 Source Code files are provided in both binary packge (commons-lang3-3.12.0-bin.zip) and source package (commons-lang3-3.12.0-src.zip). You can download them at Apache Commons Lang Website.
Apache Commons Lang 3 Source Code has no dependencies and is compatible with Java 8 and newer versions. You can compile it to generate your own version of Apache Commons Lang 3 JAR file.
You can also browse the source code below:
✍: FYIcenter
⏎ org/apache/commons/lang3/ThreadUtils.java
/* * 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.time.Duration; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.List; import org.apache.commons.lang3.time.DurationUtils; /** * <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 { /** * A predicate implementation which always returns true. */ private static final class AlwaysTruePredicate implements ThreadPredicate, ThreadGroupPredicate { private AlwaysTruePredicate() { } @Override public boolean test(final Thread thread) { return true; } @Override public boolean test(final ThreadGroup threadGroup) { 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) { Validate.notNull(name, "name"); this.name = name; } @Override public boolean test(final Thread thread) { return thread != null && thread.getName().equals(name); } @Override public boolean test(final ThreadGroup threadGroup) { return threadGroup != null && threadGroup.getName().equals(name); } } /** * A predicate for selecting threadgroups. */ // When breaking BC, replace this with Predicate<ThreadGroup> @FunctionalInterface public interface ThreadGroupPredicate { /** * 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); } /** * 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) { 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; } } /** * A predicate for selecting threads. */ // When breaking BC, replace this with Predicate<Thread> @FunctionalInterface public interface ThreadPredicate { /** * 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); } /** * Predicate which always returns true. */ public static final AlwaysTruePredicate ALWAYS_TRUE_PREDICATE = new AlwaysTruePredicate(); /** * Finds 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(); } /** * Finds the active thread with the specified id if it belongs 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) { Validate.notNull(threadGroupName, "threadGroupName"); final Thread thread = findThreadById(threadId); if (thread != null && thread.getThreadGroup() != null && thread.getThreadGroup().getName().equals(threadGroupName)) { return thread; } return null; } /** * Finds the active thread with the specified id if it belongs 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) { Validate.notNull(threadGroup, "threadGroup"); final Thread thread = findThreadById(threadId); if (thread != null && threadGroup.equals(thread.getThreadGroup())) { return thread; } return null; } /** * 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) { Validate.notNull(group, "group"); Validate.notNull(predicate, "predicate"); 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<>(count); for (int i = 0; i < count; ++i) { if (predicate.test(threadGroups[i])) { result.add(threadGroups[i]); } } return Collections.unmodifiableCollection(result); } /** * 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); } /** * Finds 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)); } /** * 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) { Validate.notNull(group, "The group must not be null"); Validate.notNull(predicate, "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<>(count); for (int i = 0; i < count; ++i) { if (predicate.test(threads[i])) { result.add(threads[i]); } } return Collections.unmodifiableCollection(result); } /** * 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); } /** * Finds 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)); } /** * Finds 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) { Validate.notNull(threadName, "threadName"); Validate.notNull(threadGroupName, "threadGroupName"); final Collection<ThreadGroup> threadGroups = findThreadGroups(new NamePredicate(threadGroupName)); if (threadGroups.isEmpty()) { return Collections.emptyList(); } final Collection<Thread> result = new ArrayList<>(); final NamePredicate threadNamePredicate = new NamePredicate(threadName); for (final ThreadGroup group : threadGroups) { result.addAll(findThreads(group, false, threadNamePredicate)); } return Collections.unmodifiableCollection(result); } /** * Finds 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)); } /** * Gets 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); } /** * Gets 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); } /** * Gets 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; } /** * Waits for the given thread to die for the given duration. Implemented using {@link Thread#join(long, int)}. * * @param thread The thread to join. * @param duration How long to wait. * @throws InterruptedException if any thread has interrupted the current thread. * @see Thread#join(long, int) * @since 3.12.0 */ public static void join(final Thread thread, final Duration duration) throws InterruptedException { DurationUtils.accept(thread::join, duration); } /** * Sleeps the current thread for the given duration. Implemented using {@link Thread#sleep(long, int)}. * * @param duration How long to sleep. * @throws InterruptedException if any thread has interrupted the current thread. * @see Thread#sleep(long, int) * @since 3.12.0 */ public static void sleep(final Duration duration) throws InterruptedException { DurationUtils.accept(Thread::sleep, duration); } /** * <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() { } }
⏎ org/apache/commons/lang3/ThreadUtils.java
Or download all of them as a single archive file:
File name: commons-lang3-3.12.0-sources.jar File size: 651724 bytes Release date: 2020-01-22 Download
⇒ Download and Install commons-lang3-3.8.1-bin.zip
⇐ Download Apache Commons Lang v3 Source Package
2022-10-19, 150654👍, 3💬
Popular Posts:
What Is mail.jar of JavaMail 1.4? I got the JAR file from javamail-1_4.zip. mail.jar in javamail-1_4...
Saxon is an open source product available under the Mozilla Public License. It provides implementati...
Provides support for the runtime platform, core utility methods and the extension registry. JAR File...
How to read XML document with XML Schema validation from socket connections with the socket\DelayedI...
What is the jaxp\SourceValidator.jav aprovided in the Apache Xerces package? I have Apache Xerces 2....