ThreadUtil (hutool-core 4.6.4 API)

java.lang.Object
- cn.hutool.core.thread.ThreadUtil

```
public class ThreadUtil
extends Object
```
线程池工具

作者:

luxiaolei

构造器概要

构造器
构造器和说明

ThreadUtil()

构造器
构造器和说明
`ThreadUtil()`

方法概要

方法
限定符和类型	方法和说明
`static ConcurrencyTester`	`concurrencyTest(int threadSize, Runnable runnable)` 并发测试此方法用于测试多线程下执行某些逻辑的并发性能调用此方法会导致当前线程阻塞。
`static ThreadFactoryBuilder`	`createThreadFactoryBuilder()` 创建ThreadFactoryBuilder
`static <T> ThreadLocal<T>`	`createThreadLocal(boolean isInheritable)` 创建本地线程对象
`static ThreadGroup`	`currentThreadGroup()` 获取当前线程的线程组
`static Runnable`	`excAsync(Runnable runnable, boolean isDeamon)` 执行异步方法
`static <T> Future<T>`	`execAsync(Callable<T> task)` 执行有返回值的异步方法 Future代表一个异步执行的操作，通过get()方法可以获得操作的结果，如果异步操作还没有完成，则，get()会使当前线程阻塞
`static Future<?>`	`execAsync(Runnable runnable)` 执行有返回值的异步方法 Future代表一个异步执行的操作，通过get()方法可以获得操作的结果，如果异步操作还没有完成，则，get()会使当前线程阻塞
`static void`	`execute(Runnable runnable)` 直接在公共线程池中执行线程
`static Thread`	`getMainThread()` 获取进程的主线程 from Voovan
`static StackTraceElement[]`	`getStackTrace()`
`static StackTraceElement`	`getStackTraceElement(int i)` 获得堆栈项
`static Thread[]`	`getThreads()` 获取JVM中与当前线程同组的所有线程
`static Thread[]`	`getThreads(ThreadGroup group)` 获取JVM中与当前线程同组的所有线程使用数组二次拷贝方式，防止在线程列表获取过程中线程终止 from Voovan
`static void`	`interupt(Thread thread, boolean isJoin)` 结束线程，调用此方法后，线程将抛出 `InterruptedException`异常
`static <T> CompletionService<T>`	`newCompletionService()` 新建一个CompletionService，调用其submit方法可以异步执行多个任务，最后调用take方法按照完成的顺序获得其结果。
`static <T> CompletionService<T>`	`newCompletionService(ExecutorService executor)` 新建一个CompletionService，调用其submit方法可以异步执行多个任务，最后调用take方法按照完成的顺序获得其结果。
`static CountDownLatch`	`newCountDownLatch(int threadCount)` 新建一个CountDownLatch，一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。
`static ExecutorService`	`newExecutor()` 获得一个新的线程池
`static ExecutorService`	`newExecutor(int threadSize)` 新建一个线程池
`static ThreadPoolExecutor`	`newExecutor(int corePoolSize, int maximumPoolSize)` 获得一个新的线程池如果maximumPoolSize =》 corePoolSize，在没有新任务加入的情况下，多出的线程将最多保留60s
`static ThreadPoolExecutor`	`newExecutorByBlockingCoefficient(float blockingCoefficient)` 获得一个新的线程池传入阻塞系数，线程池的大小计算公式为：CPU可用核心数 / (1 - 阻塞因子) Blocking Coefficient(阻塞系数) = 阻塞时间／（阻塞时间+使用CPU的时间）计算密集型任务的阻塞系数为0，而IO密集型任务的阻塞系数则接近于1。
`static ThreadFactory`	`newNamedThreadFactory(String prefix, boolean isDeamon)` 创建线程工厂
`static ThreadFactory`	`newNamedThreadFactory(String prefix, ThreadGroup threadGroup, boolean isDeamon)` 创建线程工厂
`static ThreadFactory`	`newNamedThreadFactory(String prefix, ThreadGroup threadGroup, boolean isDeamon, Thread.UncaughtExceptionHandler handler)` 创建线程工厂
`static ExecutorService`	`newSingleExecutor()` 获得一个新的线程池，只有单个线程
`static Thread`	`newThread(Runnable runnable, String name)` 创建新线程，非守护线程，正常优先级，线程组与当前线程的线程组一致
`static Thread`	`newThread(Runnable runnable, String name, boolean isDeamon)` 创建新线程
`static boolean`	`safeSleep(Number millis)` 考虑`Thread.sleep(long)`方法有可能时间不足给定毫秒数，此方法保证sleep时间不小于给定的毫秒数
`static boolean`	`sleep(Number millis)` 挂起当前线程
`static boolean`	`sleep(Number timeout, TimeUnit timeUnit)` 挂起当前线程
`static void`	`sync(Object obj)` 阻塞当前线程，保证在main方法中执行不被退出
`static void`	`waitForDie(Thread thread)` 等待线程结束.

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 构造器详细资料
  - ThreadUtil
```
public ThreadUtil()
```
- 方法详细资料
  - newExecutor
```
public static ExecutorService newExecutor(int threadSize)
```
    新建一个线程池
    
    参数:
    threadSize - 同时执行的线程数大小
    
    返回:
    ExecutorService
  - newExecutor
```
public static ExecutorService newExecutor()
```
    获得一个新的线程池
    
    返回:
    ExecutorService
  - newSingleExecutor
```
public static ExecutorService newSingleExecutor()
```
    获得一个新的线程池，只有单个线程
    
    返回:
    ExecutorService
  - newExecutor
```
public static ThreadPoolExecutor newExecutor(int corePoolSize,
                             int maximumPoolSize)
```
    获得一个新的线程池
    如果maximumPoolSize =》 corePoolSize，在没有新任务加入的情况下，多出的线程将最多保留60s
    
    参数:
    corePoolSize - 初始线程池大小
    maximumPoolSize - 最大线程池大小
    
    返回:
    ThreadPoolExecutor
  - newExecutorByBlockingCoefficient
```
public static ThreadPoolExecutor newExecutorByBlockingCoefficient(float blockingCoefficient)
```
    获得一个新的线程池
    传入阻塞系数，线程池的大小计算公式为：CPU可用核心数 / (1 - 阻塞因子)
    Blocking Coefficient(阻塞系数) = 阻塞时间／（阻塞时间+使用CPU的时间）
    计算密集型任务的阻塞系数为0，而IO密集型任务的阻塞系数则接近于1。 see: http://blog.csdn.net/partner4java/article/details/9417663
    
    参数:
    blockingCoefficient - 阻塞系数，阻塞因子介于0~1之间的数，阻塞因子越大，线程池中的线程数越多。
    
    返回:
    ThreadPoolExecutor
    从以下版本开始:
    
    3.0.6
  - execute
```
public static void execute(Runnable runnable)
```
    直接在公共线程池中执行线程
    
    参数:
    runnable - 可运行对象
  - excAsync
```
public static Runnable excAsync(Runnable runnable,
                boolean isDeamon)
```
    执行异步方法
    
    参数:
    runnable - 需要执行的方法体
    isDeamon - 是否守护线程。守护线程会在主线程结束后自动结束
    
    返回:
    执行的方法体
  - execAsync
```
public static <T> Future<T> execAsync(Callable<T> task)
```
    执行有返回值的异步方法
    Future代表一个异步执行的操作，通过get()方法可以获得操作的结果，如果异步操作还没有完成，则，get()会使当前线程阻塞
    
    类型参数:
    T - 回调对象类型
    参数:
    task - Callable
    
    返回:
    Future
  - execAsync
```
public static Future<?> execAsync(Runnable runnable)
```
    执行有返回值的异步方法
    Future代表一个异步执行的操作，通过get()方法可以获得操作的结果，如果异步操作还没有完成，则，get()会使当前线程阻塞
    
    参数:
    runnable - 可运行对象
    
    返回:
    Future
    从以下版本开始:
    
    3.0.5
  - newCompletionService
```
public static <T> CompletionService<T> newCompletionService()
```
    新建一个CompletionService，调用其submit方法可以异步执行多个任务，最后调用take方法按照完成的顺序获得其结果。
    若未完成，则会阻塞
    
    类型参数:
    T - 回调对象类型
    
    返回:
    CompletionService
  - newCompletionService
```
public static <T> CompletionService<T> newCompletionService(ExecutorService executor)
```
    新建一个CompletionService，调用其submit方法可以异步执行多个任务，最后调用take方法按照完成的顺序获得其结果。
    若未完成，则会阻塞
    
    类型参数:
    T - 回调对象类型
    参数:
    executor - 执行器 ExecutorService
    
    返回:
    CompletionService
  - newCountDownLatch
```
public static CountDownLatch newCountDownLatch(int threadCount)
```
    新建一个CountDownLatch，一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。
    
    参数:
    threadCount - 线程数量
    
    返回:
    CountDownLatch
  - newThread
```
public static Thread newThread(Runnable runnable,
               String name)
```
    创建新线程，非守护线程，正常优先级，线程组与当前线程的线程组一致
    
    参数:
    runnable - Runnable
    name - 线程名
    
    返回:
    Thread
    从以下版本开始:
    
    3.1.2
  - newThread
```
public static Thread newThread(Runnable runnable,
               String name,
               boolean isDeamon)
```
    创建新线程
    
    参数:
    runnable - Runnable
    name - 线程名
    isDeamon - 是否守护线程
    
    返回:
    Thread
    从以下版本开始:
    
    4.1.2
  - sleep
```
public static boolean sleep(Number timeout,
            TimeUnit timeUnit)
```
    挂起当前线程
    
    参数:
    timeout - 挂起的时长
    timeUnit - 时长单位
    
    返回:
    被中断返回false，否则true
  - sleep
```
public static boolean sleep(Number millis)
```
    挂起当前线程
    
    参数:
    millis - 挂起的毫秒数
    
    返回:
    被中断返回false，否则true
  - safeSleep
```
public static boolean safeSleep(Number millis)
```
    考虑Thread.sleep(long)方法有可能时间不足给定毫秒数，此方法保证sleep时间不小于给定的毫秒数
    
    参数:
    millis - 给定的sleep时间
    
    返回:
    被中断返回false，否则true
    另请参阅:
    sleep(Number)
  - getStackTrace
```
public static StackTraceElement[] getStackTrace()
```
    返回:
    获得堆栈列表
  - getStackTraceElement
```
public static StackTraceElement getStackTraceElement(int i)
```
    获得堆栈项
    
    参数:
    i - 第几个堆栈项
    
    返回:
    堆栈项
  - createThreadLocal
```
public static <T> ThreadLocal<T> createThreadLocal(boolean isInheritable)
```
    创建本地线程对象
    
    类型参数:
    T - 持有对象类型
    参数:
    isInheritable - 是否为子线程提供从父线程那里继承的值
    
    返回:
    本地线程
  - createThreadFactoryBuilder
```
public static ThreadFactoryBuilder createThreadFactoryBuilder()
```
    创建ThreadFactoryBuilder
    
    返回:
    ThreadFactoryBuilder
    从以下版本开始:
    
    4.1.13
    
    另请参阅:
    ThreadFactoryBuilder.build()
  - interupt
```
public static void interupt(Thread thread,
            boolean isJoin)
```
    结束线程，调用此方法后，线程将抛出 InterruptedException异常
    
    参数:
    thread - 线程
    isJoin - 是否等待结束
  - waitForDie
```
public static void waitForDie(Thread thread)
```
    等待线程结束. 调用 Thread.join() 并忽略 InterruptedException
    
    参数:
    thread - 线程
  - getThreads
```
public static Thread[] getThreads()
```
    获取JVM中与当前线程同组的所有线程
    
    返回:
    线程对象数组
  - getThreads
```
public static Thread[] getThreads(ThreadGroup group)
```
    获取JVM中与当前线程同组的所有线程
    使用数组二次拷贝方式，防止在线程列表获取过程中线程终止
    from Voovan
    
    参数:
    group - 线程组
    
    返回:
    线程对象数组
  - getMainThread
```
public static Thread getMainThread()
```
    获取进程的主线程
    from Voovan
    
    返回:
    进程的主线程
  - currentThreadGroup
```
public static ThreadGroup currentThreadGroup()
```
    获取当前线程的线程组
    
    返回:
    线程组
    从以下版本开始:
    
    3.1.2
  - newNamedThreadFactory
```
public static ThreadFactory newNamedThreadFactory(String prefix,
                                  boolean isDeamon)
```
    创建线程工厂
    
    参数:
    prefix - 线程名前缀
    isDeamon - 是否守护线程
    从以下版本开始:
    
    4.0.0
  - newNamedThreadFactory
```
public static ThreadFactory newNamedThreadFactory(String prefix,
                                  ThreadGroup threadGroup,
                                  boolean isDeamon)
```
    创建线程工厂
    
    参数:
    prefix - 线程名前缀
    threadGroup - 线程组，可以为null
    isDeamon - 是否守护线程
    从以下版本开始:
    
    4.0.0
  - newNamedThreadFactory
```
public static ThreadFactory newNamedThreadFactory(String prefix,
                                  ThreadGroup threadGroup,
                                  boolean isDeamon,
                                  Thread.UncaughtExceptionHandler handler)
```
    创建线程工厂
    
    参数:
    prefix - 线程名前缀
    threadGroup - 线程组，可以为null
    isDeamon - 是否守护线程
    handler - 未捕获异常处理
    从以下版本开始:
    
    4.0.0
  - sync
```
public static void sync(Object obj)
```
    阻塞当前线程，保证在main方法中执行不被退出
    
    参数:
    obj - 对象所在线程
    从以下版本开始:
    
    4.5.6
  - concurrencyTest
```
public static ConcurrencyTester concurrencyTest(int threadSize,
                                Runnable runnable)
```
    并发测试
    此方法用于测试多线程下执行某些逻辑的并发性能
    调用此方法会导致当前线程阻塞。
    结束后可调用ConcurrencyTester.getInterval() 方法获取执行时间
    
    参数:
    threadSize - 并发线程数
    runnable - 执行的逻辑实现
    
    返回:
    ConcurrencyTester
    从以下版本开始:
    
    4.5.8

类 ThreadUtil

构造器概要

方法概要

从类继承的方法 java.lang.Object

构造器详细资料

ThreadUtil

方法详细资料

newExecutor

newExecutor

newSingleExecutor

newExecutor

newExecutorByBlockingCoefficient

execute

excAsync

execAsync

execAsync

newCompletionService

newCompletionService

newCountDownLatch

newThread

newThread

sleep

sleep

safeSleep

getStackTrace

getStackTraceElement

createThreadLocal

createThreadFactoryBuilder

interupt

waitForDie

getThreads

getThreads

getMainThread

currentThreadGroup

newNamedThreadFactory

newNamedThreadFactory

newNamedThreadFactory

sync

concurrencyTest