com.mediamain.android.base.util

类 FoxBaseThreadUtils

java.lang.Object

com.mediamain.android.base.util.FoxBaseThreadUtils

public class FoxBaseThreadUtils
extends java.lang.Object

嵌套类概要

嵌套类

限定符和类型	类和说明
static class	FoxBaseThreadUtils.SimpleTask<T>
static class	FoxBaseThreadUtils.Task<T>

构造器概要

构造器

构造器和说明
FoxBaseThreadUtils()

方法概要

限定符和类型	方法和说明
static void	cancel(java.util.concurrent.ExecutorService executorService) Cancel the tasks in pool.
static void	cancel(FoxBaseThreadUtils.Task... tasks) Cancel the given tasks.
static void	cancel(FoxBaseThreadUtils.Task task) Cancel the given task.
static void	cancel(java.util.List<FoxBaseThreadUtils.Task> tasks) Cancel the given tasks.
static <T> void	executeByCached(FoxBaseThreadUtils.Task<T> task) Executes the given task in a cached thread pool.
static <T> void	executeByCached(FoxBaseThreadUtils.Task<T> task, int priority) Executes the given task in a cached thread pool.
static <T> void	executeByCachedAtFixRate(FoxBaseThreadUtils.Task<T> task, long initialDelay, long period, java.util.concurrent.TimeUnit unit) Executes the given task in a cached thread pool at fix rate.
static <T> void	executeByCachedAtFixRate(FoxBaseThreadUtils.Task<T> task, long initialDelay, long period, java.util.concurrent.TimeUnit unit, int priority) Executes the given task in a cached thread pool at fix rate.
static <T> void	executeByCachedAtFixRate(FoxBaseThreadUtils.Task<T> task, long period, java.util.concurrent.TimeUnit unit) Executes the given task in a cached thread pool at fix rate.
static <T> void	executeByCachedAtFixRate(FoxBaseThreadUtils.Task<T> task, long period, java.util.concurrent.TimeUnit unit, int priority) Executes the given task in a cached thread pool at fix rate.
static <T> void	executeByCachedWithDelay(FoxBaseThreadUtils.Task<T> task, long delay, java.util.concurrent.TimeUnit unit) Executes the given task in a cached thread pool after the given delay.
static <T> void	executeByCachedWithDelay(FoxBaseThreadUtils.Task<T> task, long delay, java.util.concurrent.TimeUnit unit, int priority) Executes the given task in a cached thread pool after the given delay.
static <T> void	executeByCpu(FoxBaseThreadUtils.Task<T> task) Executes the given task in a cpu thread pool.
static <T> void	executeByCpu(FoxBaseThreadUtils.Task<T> task, int priority) Executes the given task in a cpu thread pool.
static <T> void	executeByCpuAtFixRate(FoxBaseThreadUtils.Task<T> task, long initialDelay, long period, java.util.concurrent.TimeUnit unit) Executes the given task in a cpu thread pool at fix rate.
static <T> void	executeByCpuAtFixRate(FoxBaseThreadUtils.Task<T> task, long initialDelay, long period, java.util.concurrent.TimeUnit unit, int priority) Executes the given task in a cpu thread pool at fix rate.
static <T> void	executeByCpuAtFixRate(FoxBaseThreadUtils.Task<T> task, long period, java.util.concurrent.TimeUnit unit) Executes the given task in a cpu thread pool at fix rate.
static <T> void	executeByCpuAtFixRate(FoxBaseThreadUtils.Task<T> task, long period, java.util.concurrent.TimeUnit unit, int priority) Executes the given task in a cpu thread pool at fix rate.
static <T> void	executeByCpuWithDelay(FoxBaseThreadUtils.Task<T> task, long delay, java.util.concurrent.TimeUnit unit) Executes the given task in a cpu thread pool after the given delay.
static <T> void	executeByCpuWithDelay(FoxBaseThreadUtils.Task<T> task, long delay, java.util.concurrent.TimeUnit unit, int priority) Executes the given task in a cpu thread pool after the given delay.
static <T> void	executeByCustom(java.util.concurrent.ExecutorService pool, FoxBaseThreadUtils.Task<T> task) Executes the given task in a custom thread pool.
static <T> void	executeByCustomAtFixRate(java.util.concurrent.ExecutorService pool, FoxBaseThreadUtils.Task<T> task, long initialDelay, long period, java.util.concurrent.TimeUnit unit) Executes the given task in a custom thread pool at fix rate.
static <T> void	executeByCustomAtFixRate(java.util.concurrent.ExecutorService pool, FoxBaseThreadUtils.Task<T> task, long period, java.util.concurrent.TimeUnit unit) Executes the given task in a custom thread pool at fix rate.
static <T> void	executeByCustomWithDelay(java.util.concurrent.ExecutorService pool, FoxBaseThreadUtils.Task<T> task, long delay, java.util.concurrent.TimeUnit unit) Executes the given task in a custom thread pool after the given delay.
static <T> void	executeByFixed(int size, FoxBaseThreadUtils.Task<T> task) Executes the given task in a fixed thread pool.
static <T> void	executeByFixed(int size, FoxBaseThreadUtils.Task<T> task, int priority) Executes the given task in a fixed thread pool.
static <T> void	executeByFixedAtFixRate(int size, FoxBaseThreadUtils.Task<T> task, long initialDelay, long period, java.util.concurrent.TimeUnit unit) Executes the given task in a fixed thread pool at fix rate.
static <T> void	executeByFixedAtFixRate(int size, FoxBaseThreadUtils.Task<T> task, long initialDelay, long period, java.util.concurrent.TimeUnit unit, int priority) Executes the given task in a fixed thread pool at fix rate.
static <T> void	executeByFixedAtFixRate(int size, FoxBaseThreadUtils.Task<T> task, long period, java.util.concurrent.TimeUnit unit) Executes the given task in a fixed thread pool at fix rate.
static <T> void	executeByFixedAtFixRate(int size, FoxBaseThreadUtils.Task<T> task, long period, java.util.concurrent.TimeUnit unit, int priority) Executes the given task in a fixed thread pool at fix rate.
static <T> void	executeByFixedWithDelay(int size, FoxBaseThreadUtils.Task<T> task, long delay, java.util.concurrent.TimeUnit unit) Executes the given task in a fixed thread pool after the given delay.
static <T> void	executeByFixedWithDelay(int size, FoxBaseThreadUtils.Task<T> task, long delay, java.util.concurrent.TimeUnit unit, int priority) Executes the given task in a fixed thread pool after the given delay.
static <T> void	executeByIo(FoxBaseThreadUtils.Task<T> task) Executes the given task in an IO thread pool.
static <T> void	executeByIo(FoxBaseThreadUtils.Task<T> task, int priority) Executes the given task in an IO thread pool.
static <T> void	executeByIoAtFixRate(FoxBaseThreadUtils.Task<T> task, long initialDelay, long period, java.util.concurrent.TimeUnit unit) Executes the given task in an IO thread pool at fix rate.
static <T> void	executeByIoAtFixRate(FoxBaseThreadUtils.Task<T> task, long initialDelay, long period, java.util.concurrent.TimeUnit unit, int priority) Executes the given task in an IO thread pool at fix rate.
static <T> void	executeByIoAtFixRate(FoxBaseThreadUtils.Task<T> task, long period, java.util.concurrent.TimeUnit unit) Executes the given task in an IO thread pool at fix rate.
static <T> void	executeByIoAtFixRate(FoxBaseThreadUtils.Task<T> task, long period, java.util.concurrent.TimeUnit unit, int priority) Executes the given task in an IO thread pool at fix rate.
static <T> void	executeByIoWithDelay(FoxBaseThreadUtils.Task<T> task, long delay, java.util.concurrent.TimeUnit unit) Executes the given task in an IO thread pool after the given delay.
static <T> void	executeByIoWithDelay(FoxBaseThreadUtils.Task<T> task, long delay, java.util.concurrent.TimeUnit unit, int priority) Executes the given task in an IO thread pool after the given delay.
static <T> void	executeBySingle(FoxBaseThreadUtils.Task<T> task) Executes the given task in a single thread pool.
static <T> void	executeBySingle(FoxBaseThreadUtils.Task<T> task, int priority) Executes the given task in a single thread pool.
static <T> void	executeBySingleAtFixRate(FoxBaseThreadUtils.Task<T> task, long initialDelay, long period, java.util.concurrent.TimeUnit unit) Executes the given task in a single thread pool at fix rate.
static <T> void	executeBySingleAtFixRate(FoxBaseThreadUtils.Task<T> task, long initialDelay, long period, java.util.concurrent.TimeUnit unit, int priority) Executes the given task in a single thread pool at fix rate.
static <T> void	executeBySingleAtFixRate(FoxBaseThreadUtils.Task<T> task, long period, java.util.concurrent.TimeUnit unit) Executes the given task in a single thread pool at fix rate.
static <T> void	executeBySingleAtFixRate(FoxBaseThreadUtils.Task<T> task, long period, java.util.concurrent.TimeUnit unit, int priority) Executes the given task in a single thread pool at fix rate.
static <T> void	executeBySingleWithDelay(FoxBaseThreadUtils.Task<T> task, long delay, java.util.concurrent.TimeUnit unit) Executes the given task in a single thread pool after the given delay.
static <T> void	executeBySingleWithDelay(FoxBaseThreadUtils.Task<T> task, long delay, java.util.concurrent.TimeUnit unit, int priority) Executes the given task in a single thread pool after the given delay.
static java.util.concurrent.ExecutorService	getCachedPool() Return a thread pool that creates new threads as needed, but will reuse previously constructed threads when they are available.
static java.util.concurrent.ExecutorService	getCachedPool(int priority) Return a thread pool that creates new threads as needed, but will reuse previously constructed threads when they are available.
static java.util.concurrent.ExecutorService	getCpuPool() Return a thread pool that creates (CPU_COUNT + 1) threads operating off a queue which size is 128 and the maximum number of threads equals (2 * CPU_COUNT + 1).
static java.util.concurrent.ExecutorService	getCpuPool(int priority) Return a thread pool that creates (CPU_COUNT + 1) threads operating off a queue which size is 128 and the maximum number of threads equals (2 * CPU_COUNT + 1).
static java.util.concurrent.ExecutorService	getFixedPool(int size) Return a thread pool that reuses a fixed number of threads operating off a shared unbounded queue, using the provided ThreadFactory to create new threads when needed.
static java.util.concurrent.ExecutorService	getFixedPool(int size, int priority) Return a thread pool that reuses a fixed number of threads operating off a shared unbounded queue, using the provided ThreadFactory to create new threads when needed.
static java.util.concurrent.ExecutorService	getIoPool() Return a thread pool that creates (2 * CPU_COUNT + 1) threads operating off a queue which size is 128.
static java.util.concurrent.ExecutorService	getIoPool(int priority) Return a thread pool that creates (2 * CPU_COUNT + 1) threads operating off a queue which size is 128.
static java.util.concurrent.ExecutorService	getSinglePool() Return a thread pool that uses a single worker thread operating off an unbounded queue, and uses the provided ThreadFactory to create a new thread when needed.
static java.util.concurrent.ExecutorService	getSinglePool(int priority) Return a thread pool that uses a single worker thread operating off an unbounded queue, and uses the provided ThreadFactory to create a new thread when needed.
static boolean	isMainThread() Return whether the thread is the main thread.
static void	setDeliver(java.util.concurrent.Executor deliver) Set the deliver.

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

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

构造器详细资料

FoxBaseThreadUtils

public FoxBaseThreadUtils()

方法详细资料

isMainThread

public static boolean isMainThread()

Return whether the thread is the main thread.

返回:

true: yes
false: no

getFixedPool

public static java.util.concurrent.ExecutorService getFixedPool(int size)

Return a thread pool that reuses a fixed number of threads operating off a shared unbounded queue, using the provided ThreadFactory to create new threads when needed.

参数:

size - The size of thread in the pool.

返回:

a fixed thread pool

getFixedPool

public static java.util.concurrent.ExecutorService getFixedPool(int size,
                                                                int priority)

Return a thread pool that reuses a fixed number of threads operating off a shared unbounded queue, using the provided ThreadFactory to create new threads when needed.

参数:

size - The size of thread in the pool.

priority - The priority of thread in the poll.

返回:

a fixed thread pool

getSinglePool

public static java.util.concurrent.ExecutorService getSinglePool()

Return a thread pool that uses a single worker thread operating off an unbounded queue, and uses the provided ThreadFactory to create a new thread when needed.

返回:

a single thread pool

getSinglePool

public static java.util.concurrent.ExecutorService getSinglePool(int priority)

Return a thread pool that uses a single worker thread operating off an unbounded queue, and uses the provided ThreadFactory to create a new thread when needed.

参数:

priority - The priority of thread in the poll.

返回:

a single thread pool

getCachedPool

public static java.util.concurrent.ExecutorService getCachedPool()

Return a thread pool that creates new threads as needed, but will reuse previously constructed threads when they are available.

返回:

a cached thread pool

getCachedPool

public static java.util.concurrent.ExecutorService getCachedPool(int priority)

Return a thread pool that creates new threads as needed, but will reuse previously constructed threads when they are available.

参数:

priority - The priority of thread in the poll.

返回:

a cached thread pool

getIoPool

public static java.util.concurrent.ExecutorService getIoPool()

Return a thread pool that creates (2 * CPU_COUNT + 1) threads operating off a queue which size is 128.

返回:

a IO thread pool

getIoPool

public static java.util.concurrent.ExecutorService getIoPool(int priority)

Return a thread pool that creates (2 * CPU_COUNT + 1) threads operating off a queue which size is 128.

参数:

priority - The priority of thread in the poll.

返回:

a IO thread pool

getCpuPool

public static java.util.concurrent.ExecutorService getCpuPool()

Return a thread pool that creates (CPU_COUNT + 1) threads operating off a queue which size is 128 and the maximum number of threads equals (2 * CPU_COUNT + 1).

返回:

a cpu thread pool for

getCpuPool

public static java.util.concurrent.ExecutorService getCpuPool(int priority)

Return a thread pool that creates (CPU_COUNT + 1) threads operating off a queue which size is 128 and the maximum number of threads equals (2 * CPU_COUNT + 1).

参数:

priority - The priority of thread in the poll.

返回:

a cpu thread pool for

executeByFixed

public static <T> void executeByFixed(int size,
                                      FoxBaseThreadUtils.Task<T> task)

Executes the given task in a fixed thread pool.

类型参数:

T - The type of the task's result.

参数:

size - The size of thread in the fixed thread pool.

task - The task to execute.

executeByFixed

public static <T> void executeByFixed(int size,
                                      FoxBaseThreadUtils.Task<T> task,
                                      int priority)

Executes the given task in a fixed thread pool.

类型参数:

T - The type of the task's result.

参数:

size - The size of thread in the fixed thread pool.

task - The task to execute.

priority - The priority of thread in the poll.

executeByFixedWithDelay

public static <T> void executeByFixedWithDelay(int size,
                                               FoxBaseThreadUtils.Task<T> task,
                                               long delay,
                                               java.util.concurrent.TimeUnit unit)

Executes the given task in a fixed thread pool after the given delay.

类型参数:

T - The type of the task's result.

参数:

size - The size of thread in the fixed thread pool.

task - The task to execute.

delay - The time from now to delay execution.

unit - The time unit of the delay parameter.

executeByFixedWithDelay

public static <T> void executeByFixedWithDelay(int size,
                                               FoxBaseThreadUtils.Task<T> task,
                                               long delay,
                                               java.util.concurrent.TimeUnit unit,
                                               int priority)

Executes the given task in a fixed thread pool after the given delay.

类型参数:

T - The type of the task's result.

参数:

size - The size of thread in the fixed thread pool.

task - The task to execute.

delay - The time from now to delay execution.

unit - The time unit of the delay parameter.

priority - The priority of thread in the poll.

executeByFixedAtFixRate

public static <T> void executeByFixedAtFixRate(int size,
                                               FoxBaseThreadUtils.Task<T> task,
                                               long period,
                                               java.util.concurrent.TimeUnit unit)

Executes the given task in a fixed thread pool at fix rate.

类型参数:

T - The type of the task's result.

参数:

size - The size of thread in the fixed thread pool.

task - The task to execute.

period - The period between successive executions.

unit - The time unit of the period parameter.

executeByFixedAtFixRate

public static <T> void executeByFixedAtFixRate(int size,
                                               FoxBaseThreadUtils.Task<T> task,
                                               long period,
                                               java.util.concurrent.TimeUnit unit,
                                               int priority)

Executes the given task in a fixed thread pool at fix rate.

类型参数:

T - The type of the task's result.

参数:

size - The size of thread in the fixed thread pool.

task - The task to execute.

period - The period between successive executions.

unit - The time unit of the period parameter.

priority - The priority of thread in the poll.

executeByFixedAtFixRate

public static <T> void executeByFixedAtFixRate(int size,
                                               FoxBaseThreadUtils.Task<T> task,
                                               long initialDelay,
                                               long period,
                                               java.util.concurrent.TimeUnit unit)

Executes the given task in a fixed thread pool at fix rate.

类型参数:

T - The type of the task's result.

参数:

size - The size of thread in the fixed thread pool.

task - The task to execute.

initialDelay - The time to delay first execution.

period - The period between successive executions.

unit - The time unit of the initialDelay and period parameters.

executeByFixedAtFixRate

public static <T> void executeByFixedAtFixRate(int size,
                                               FoxBaseThreadUtils.Task<T> task,
                                               long initialDelay,
                                               long period,
                                               java.util.concurrent.TimeUnit unit,
                                               int priority)

Executes the given task in a fixed thread pool at fix rate.

类型参数:

T - The type of the task's result.

参数:

size - The size of thread in the fixed thread pool.

task - The task to execute.

initialDelay - The time to delay first execution.

period - The period between successive executions.

unit - The time unit of the initialDelay and period parameters.

priority - The priority of thread in the poll.

executeBySingle

public static <T> void executeBySingle(FoxBaseThreadUtils.Task<T> task)

Executes the given task in a single thread pool.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

executeBySingle

public static <T> void executeBySingle(FoxBaseThreadUtils.Task<T> task,
                                       int priority)

Executes the given task in a single thread pool.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

priority - The priority of thread in the poll.

executeBySingleWithDelay

public static <T> void executeBySingleWithDelay(FoxBaseThreadUtils.Task<T> task,
                                                long delay,
                                                java.util.concurrent.TimeUnit unit)

Executes the given task in a single thread pool after the given delay.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

delay - The time from now to delay execution.

unit - The time unit of the delay parameter.

executeBySingleWithDelay

public static <T> void executeBySingleWithDelay(FoxBaseThreadUtils.Task<T> task,
                                                long delay,
                                                java.util.concurrent.TimeUnit unit,
                                                int priority)

Executes the given task in a single thread pool after the given delay.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

delay - The time from now to delay execution.

unit - The time unit of the delay parameter.

priority - The priority of thread in the poll.

executeBySingleAtFixRate

public static <T> void executeBySingleAtFixRate(FoxBaseThreadUtils.Task<T> task,
                                                long period,
                                                java.util.concurrent.TimeUnit unit)

Executes the given task in a single thread pool at fix rate.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

period - The period between successive executions.

unit - The time unit of the period parameter.

executeBySingleAtFixRate

public static <T> void executeBySingleAtFixRate(FoxBaseThreadUtils.Task<T> task,
                                                long period,
                                                java.util.concurrent.TimeUnit unit,
                                                int priority)

Executes the given task in a single thread pool at fix rate.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

period - The period between successive executions.

unit - The time unit of the period parameter.

priority - The priority of thread in the poll.

executeBySingleAtFixRate

public static <T> void executeBySingleAtFixRate(FoxBaseThreadUtils.Task<T> task,
                                                long initialDelay,
                                                long period,
                                                java.util.concurrent.TimeUnit unit)

Executes the given task in a single thread pool at fix rate.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

initialDelay - The time to delay first execution.

period - The period between successive executions.

unit - The time unit of the initialDelay and period parameters.

executeBySingleAtFixRate

public static <T> void executeBySingleAtFixRate(FoxBaseThreadUtils.Task<T> task,
                                                long initialDelay,
                                                long period,
                                                java.util.concurrent.TimeUnit unit,
                                                int priority)

Executes the given task in a single thread pool at fix rate.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

initialDelay - The time to delay first execution.

period - The period between successive executions.

unit - The time unit of the initialDelay and period parameters.

priority - The priority of thread in the poll.

executeByCached

public static <T> void executeByCached(FoxBaseThreadUtils.Task<T> task)

Executes the given task in a cached thread pool.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

executeByCached

public static <T> void executeByCached(FoxBaseThreadUtils.Task<T> task,
                                       int priority)

Executes the given task in a cached thread pool.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

priority - The priority of thread in the poll.

executeByCachedWithDelay

public static <T> void executeByCachedWithDelay(FoxBaseThreadUtils.Task<T> task,
                                                long delay,
                                                java.util.concurrent.TimeUnit unit)

Executes the given task in a cached thread pool after the given delay.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

delay - The time from now to delay execution.

unit - The time unit of the delay parameter.

executeByCachedWithDelay

public static <T> void executeByCachedWithDelay(FoxBaseThreadUtils.Task<T> task,
                                                long delay,
                                                java.util.concurrent.TimeUnit unit,
                                                int priority)

Executes the given task in a cached thread pool after the given delay.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

delay - The time from now to delay execution.

unit - The time unit of the delay parameter.

priority - The priority of thread in the poll.

executeByCachedAtFixRate

public static <T> void executeByCachedAtFixRate(FoxBaseThreadUtils.Task<T> task,
                                                long period,
                                                java.util.concurrent.TimeUnit unit)

Executes the given task in a cached thread pool at fix rate.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

period - The period between successive executions.

unit - The time unit of the period parameter.

executeByCachedAtFixRate

public static <T> void executeByCachedAtFixRate(FoxBaseThreadUtils.Task<T> task,
                                                long period,
                                                java.util.concurrent.TimeUnit unit,
                                                int priority)

Executes the given task in a cached thread pool at fix rate.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

period - The period between successive executions.

unit - The time unit of the period parameter.

priority - The priority of thread in the poll.

executeByCachedAtFixRate

public static <T> void executeByCachedAtFixRate(FoxBaseThreadUtils.Task<T> task,
                                                long initialDelay,
                                                long period,
                                                java.util.concurrent.TimeUnit unit)

Executes the given task in a cached thread pool at fix rate.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

initialDelay - The time to delay first execution.

period - The period between successive executions.

unit - The time unit of the initialDelay and period parameters.

executeByCachedAtFixRate

public static <T> void executeByCachedAtFixRate(FoxBaseThreadUtils.Task<T> task,
                                                long initialDelay,
                                                long period,
                                                java.util.concurrent.TimeUnit unit,
                                                int priority)

Executes the given task in a cached thread pool at fix rate.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

initialDelay - The time to delay first execution.

period - The period between successive executions.

unit - The time unit of the initialDelay and period parameters.

priority - The priority of thread in the poll.

executeByIo

public static <T> void executeByIo(FoxBaseThreadUtils.Task<T> task)

Executes the given task in an IO thread pool.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

executeByIo

public static <T> void executeByIo(FoxBaseThreadUtils.Task<T> task,
                                   int priority)

Executes the given task in an IO thread pool.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

priority - The priority of thread in the poll.

executeByIoWithDelay

public static <T> void executeByIoWithDelay(FoxBaseThreadUtils.Task<T> task,
                                            long delay,
                                            java.util.concurrent.TimeUnit unit)

Executes the given task in an IO thread pool after the given delay.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

delay - The time from now to delay execution.

unit - The time unit of the delay parameter.

executeByIoWithDelay

public static <T> void executeByIoWithDelay(FoxBaseThreadUtils.Task<T> task,
                                            long delay,
                                            java.util.concurrent.TimeUnit unit,
                                            int priority)

Executes the given task in an IO thread pool after the given delay.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

delay - The time from now to delay execution.

unit - The time unit of the delay parameter.

priority - The priority of thread in the poll.

executeByIoAtFixRate

public static <T> void executeByIoAtFixRate(FoxBaseThreadUtils.Task<T> task,
                                            long period,
                                            java.util.concurrent.TimeUnit unit)

Executes the given task in an IO thread pool at fix rate.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

period - The period between successive executions.

unit - The time unit of the period parameter.

executeByIoAtFixRate

public static <T> void executeByIoAtFixRate(FoxBaseThreadUtils.Task<T> task,
                                            long period,
                                            java.util.concurrent.TimeUnit unit,
                                            int priority)

Executes the given task in an IO thread pool at fix rate.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

period - The period between successive executions.

unit - The time unit of the period parameter.

priority - The priority of thread in the poll.

executeByIoAtFixRate

public static <T> void executeByIoAtFixRate(FoxBaseThreadUtils.Task<T> task,
                                            long initialDelay,
                                            long period,
                                            java.util.concurrent.TimeUnit unit)

Executes the given task in an IO thread pool at fix rate.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

initialDelay - The time to delay first execution.

period - The period between successive executions.

unit - The time unit of the initialDelay and period parameters.

executeByIoAtFixRate

public static <T> void executeByIoAtFixRate(FoxBaseThreadUtils.Task<T> task,
                                            long initialDelay,
                                            long period,
                                            java.util.concurrent.TimeUnit unit,
                                            int priority)

Executes the given task in an IO thread pool at fix rate.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

initialDelay - The time to delay first execution.

period - The period between successive executions.

unit - The time unit of the initialDelay and period parameters.

priority - The priority of thread in the poll.

executeByCpu

public static <T> void executeByCpu(FoxBaseThreadUtils.Task<T> task)

Executes the given task in a cpu thread pool.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

executeByCpu

public static <T> void executeByCpu(FoxBaseThreadUtils.Task<T> task,
                                    int priority)

Executes the given task in a cpu thread pool.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

priority - The priority of thread in the poll.

executeByCpuWithDelay

public static <T> void executeByCpuWithDelay(FoxBaseThreadUtils.Task<T> task,
                                             long delay,
                                             java.util.concurrent.TimeUnit unit)

Executes the given task in a cpu thread pool after the given delay.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

delay - The time from now to delay execution.

unit - The time unit of the delay parameter.

executeByCpuWithDelay

public static <T> void executeByCpuWithDelay(FoxBaseThreadUtils.Task<T> task,
                                             long delay,
                                             java.util.concurrent.TimeUnit unit,
                                             int priority)

Executes the given task in a cpu thread pool after the given delay.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

delay - The time from now to delay execution.

unit - The time unit of the delay parameter.

priority - The priority of thread in the poll.

executeByCpuAtFixRate

public static <T> void executeByCpuAtFixRate(FoxBaseThreadUtils.Task<T> task,
                                             long period,
                                             java.util.concurrent.TimeUnit unit)

Executes the given task in a cpu thread pool at fix rate.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

period - The period between successive executions.

unit - The time unit of the period parameter.

executeByCpuAtFixRate

public static <T> void executeByCpuAtFixRate(FoxBaseThreadUtils.Task<T> task,
                                             long period,
                                             java.util.concurrent.TimeUnit unit,
                                             int priority)

Executes the given task in a cpu thread pool at fix rate.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

period - The period between successive executions.

unit - The time unit of the period parameter.

priority - The priority of thread in the poll.

executeByCpuAtFixRate

public static <T> void executeByCpuAtFixRate(FoxBaseThreadUtils.Task<T> task,
                                             long initialDelay,
                                             long period,
                                             java.util.concurrent.TimeUnit unit)

Executes the given task in a cpu thread pool at fix rate.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

initialDelay - The time to delay first execution.

period - The period between successive executions.

unit - The time unit of the initialDelay and period parameters.

executeByCpuAtFixRate

public static <T> void executeByCpuAtFixRate(FoxBaseThreadUtils.Task<T> task,
                                             long initialDelay,
                                             long period,
                                             java.util.concurrent.TimeUnit unit,
                                             int priority)

Executes the given task in a cpu thread pool at fix rate.

类型参数:

T - The type of the task's result.

参数:

task - The task to execute.

initialDelay - The time to delay first execution.

period - The period between successive executions.

unit - The time unit of the initialDelay and period parameters.

priority - The priority of thread in the poll.

executeByCustom

public static <T> void executeByCustom(java.util.concurrent.ExecutorService pool,
                                       FoxBaseThreadUtils.Task<T> task)

Executes the given task in a custom thread pool.

类型参数:

T - The type of the task's result.

参数:

pool - The custom thread pool.

task - The task to execute.

executeByCustomWithDelay

public static <T> void executeByCustomWithDelay(java.util.concurrent.ExecutorService pool,
                                                FoxBaseThreadUtils.Task<T> task,
                                                long delay,
                                                java.util.concurrent.TimeUnit unit)

Executes the given task in a custom thread pool after the given delay.

类型参数:

T - The type of the task's result.

参数:

pool - The custom thread pool.

task - The task to execute.

delay - The time from now to delay execution.

unit - The time unit of the delay parameter.

executeByCustomAtFixRate

public static <T> void executeByCustomAtFixRate(java.util.concurrent.ExecutorService pool,
                                                FoxBaseThreadUtils.Task<T> task,
                                                long period,
                                                java.util.concurrent.TimeUnit unit)

Executes the given task in a custom thread pool at fix rate.

类型参数:

T - The type of the task's result.

参数:

pool - The custom thread pool.

task - The task to execute.

period - The period between successive executions.

unit - The time unit of the period parameter.

executeByCustomAtFixRate

public static <T> void executeByCustomAtFixRate(java.util.concurrent.ExecutorService pool,
                                                FoxBaseThreadUtils.Task<T> task,
                                                long initialDelay,
                                                long period,
                                                java.util.concurrent.TimeUnit unit)

Executes the given task in a custom thread pool at fix rate.

类型参数:

T - The type of the task's result.

参数:

pool - The custom thread pool.

task - The task to execute.

initialDelay - The time to delay first execution.

period - The period between successive executions.

unit - The time unit of the initialDelay and period parameters.

cancel

public static void cancel(FoxBaseThreadUtils.Task task)

Cancel the given task.

参数:

task - The task to cancel.

cancel

public static void cancel(FoxBaseThreadUtils.Task... tasks)

Cancel the given tasks.

参数:

tasks - The tasks to cancel.

cancel

public static void cancel(java.util.List<FoxBaseThreadUtils.Task> tasks)

Cancel the given tasks.

参数:

tasks - The tasks to cancel.

cancel

public static void cancel(java.util.concurrent.ExecutorService executorService)

Cancel the tasks in pool.

参数:

executorService - The pool.

setDeliver

public static void setDeliver(java.util.concurrent.Executor deliver)

Set the deliver.

参数:

deliver - The deliver.