Loading

关于多线程一些比较关键的类(ThreadLocal Lock ReentrantLock Thread ThreadPoolExecute ThreadPoolSchduleExecute Execute ReenTrantReadWriteLock 阻塞队列)

Thread

基本介绍:

线程是程序中执行的线程。 Java虚拟机允许应用程序同时执行多个执行线程。

基本方法:

构造方法:

Thread()
分配一个新的 Thread对象。
Thread(Runnable target)
分配一个新的 Thread对象。
Thread(Runnable target, String name)
分配一个新的 Thread对象。
Thread(String name)
分配一个新的 Thread对象。
Thread(ThreadGroup group, Runnable target)
分配一个新的 Thread对象。
Thread(ThreadGroup group, Runnable target, String name)
分配一个新的 Thread对象，使其具有 target作为其运行对象，具有指定的 name作为其名称，属于 group引用的线程组。
Thread(ThreadGroup group, Runnable target, String name, long stackSize)
分配一个新的 Thread对象，以便它具有 target作为其运行对象，将指定的 name正如其名，以及属于该线程组由称作 group ，并具有指定的 堆栈大小 。
Thread(ThreadGroup group, String name)
分配一个新的 Thread对象。 

静态方法:

static int MAX_PRIORITY
线程可以拥有的最大优先级。
static int MIN_PRIORITY
线程可以拥有的最小优先级。
static int NORM_PRIORITY
分配给线程的默认优先级。 
 
static class  Thread.State
线程状态。 
static interface  Thread.UncaughtExceptionHandler
当Thread由于未捕获的异常而突然终止时，处理程序的 接口被调用。

实例方法:

static int activeCount()
返回当前线程的thread group及其子组中活动线程数的估计。
void checkAccess()
确定当前正在运行的线程是否有权限修改此线程。
protected Object clone()
将CloneNotSupportedException作为线程抛出无法有意义地克隆。
int countStackFrames()
已弃用
此呼叫的定义取决于suspend() ，它已被弃用。 此外，此呼叫的结果从未明确。
static Thread currentThread()
返回对当前正在执行的线程对象的引用。
void destroy()
已弃用
这种方法最初是为了销毁这个线程而没有任何清理。 它所持有的任何监视器都将保持锁定。 但是，该方法从未实现。 如果要实施，那么它将是suspend()的方式是僵死的 。 如果目标线程在销毁时保护关键系统资源的锁，则无法再次访问该资源。 如果另一个线程曾尝试锁定此资源，将导致死锁。 这种僵局通常表现为“冻结”过程。 有关详细信息，请参阅Why are Thread.stop, Thread.suspend and Thread.resume Deprecated? 。
static void dumpStack()
将当前线程的堆栈跟踪打印到标准错误流。
static int enumerate(Thread[] tarray)
将当前线程的线程组及其子组中的每个活动线程复制到指定的数组中。
static Map<Thread,StackTraceElement[]> getAllStackTraces()
返回所有活动线程的堆栈跟踪图。
ClassLoader getContextClassLoader()
返回此Thread的上下文ClassLoader。
static Thread.UncaughtExceptionHandler getDefaultUncaughtExceptionHandler()
返回当线程由于未捕获异常突然终止而调用的默认处理程序。
long getId()
返回此线程的标识符。
String getName()
返回此线程的名称。
int getPriority()
返回此线程的优先级。
StackTraceElement[] getStackTrace()
返回表示此线程的堆栈转储的堆栈跟踪元素数组。
Thread.State getState()
返回此线程的状态。
ThreadGroup getThreadGroup()
返回此线程所属的线程组。
Thread.UncaughtExceptionHandler getUncaughtExceptionHandler()
返回由于未捕获的异常，此线程突然终止时调用的处理程序。
static boolean holdsLock(Object obj)
返回 true当且仅当当前线程在指定的对象上保持监视器锁。
void interrupt()
中断这个线程。
static boolean interrupted()
测试当前线程是否中断。
boolean isAlive()
测试这个线程是否活着。
boolean isDaemon()
测试这个线程是否是守护线程。
boolean isInterrupted()
测试这个线程是否被中断。
void join()
等待这个线程死亡。
void join(long millis)
等待这个线程死亡最多 millis毫秒。
void join(long millis, int nanos)
等待最多 millis毫秒加上 nanos纳秒这个线程死亡。
void resume()
已弃用
该方法仅用于与suspend()一起使用，因为它是死锁倾向的，因此已被弃用。 有关详细信息，请参阅Why are Thread.stop, Thread.suspend and Thread.resume Deprecated? 。
void run()
如果这个线程使用单独的Runnable运行对象构造，则调用该Runnable对象的run方法; 否则，此方法不执行任何操作并返回。
void setContextClassLoader(ClassLoader cl)
设置此线程的上下文ClassLoader。
void setDaemon(boolean on)
将此线程标记为 daemon线程或用户线程。
static void setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)
设置当线程由于未捕获的异常突然终止而调用的默认处理程序，并且没有为该线程定义其他处理程序。
void setName(String name)
将此线程的名称更改为等于参数 name 。
void setPriority(int newPriority)
更改此线程的优先级。
void setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)
设置当该线程由于未捕获的异常而突然终止时调用的处理程序。
static void sleep(long millis)
使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行），具体取决于系统定时器和调度程序的精度和准确性。
static void sleep(long millis, int nanos)
导致正在执行的线程以指定的毫秒数加上指定的纳秒数来暂停（临时停止执行），这取决于系统定时器和调度器的精度和准确性。
void start()
导致此线程开始执行; Java虚拟机调用此线程的run方法。
void stop()
已弃用
这种方法本质上是不安全的。 使用Thread.stop停止线程可以解锁所有已锁定的监视器（由于未ThreadDeath ThreadDeath异常在堆栈中ThreadDeath的自然结果）。 如果先前受这些监视器保护的任何对象处于不一致的状态，则损坏的对象将变得对其他线程可见，可能导致任意行为。 stop许多用途应该被替换为只是修改一些变量以指示目标线程应该停止运行的代码。 目标线程应该定期检查此变量，如果变量表示要停止运行，则以有序方式从其运行方法返回。 如果目标线程长时间等待（例如，在interrupt变量上），则应该使用interrupt方法来中断等待。 有关详细信息，请参阅Why are Thread.stop, Thread.suspend and Thread.resume Deprecated? 。
void stop(Throwable obj)
已弃用
该方法最初设计为强制线程停止并抛出一个给定的Throwable作为例外。 它本质上是不安全的（有关详细信息，请参阅stop() ），此外还可用于生成目标线程未准备处理的异常。 有关详细信息，请参阅Why are Thread.stop, Thread.suspend and Thread.resume Deprecated? 。
void suspend()
已弃用
这种方法已被弃用，因为它本身就是死锁的。 如果目标线程在挂起时保护关键系统资源的监视器上的锁定，则在目标线程恢复之前，线程不能访问该资源。 如果要恢复目标线程的线程在调用resume之前尝试锁定此监视器， resume导致死锁。 这种僵局通常表现为“冻结”过程。 有关详细信息，请参阅Why are Thread.stop, Thread.suspend and Thread.resume Deprecated? 。
String toString()
返回此线程的字符串表示，包括线程的名称，优先级和线程组。
static void yield()
对调度程序的一个暗示，即当前线程愿意产生当前使用的处理器。 

ThreadLocal

基本介绍:

这个类提供线程局部变量。 这些变量与其正常的对应方式不同，因为访问一个的每个线程（通过其get或set方法）都有自己独立初始化的变量副本。 ThreadLocal实例通常是希望将状态与线程关联的类中的私有静态字段（例如，用户ID或事务ID）。

基本方法

Modifier and TypeMethod and Description
T get()
返回当前线程的此线程局部变量的副本中的值。
protected T initialValue()
返回此线程局部变量的当前线程的“初始值”。
void remove()
删除此线程局部变量的当前线程的值。
void set(T value)
将当前线程的此线程局部变量的副本设置为指定的值。
static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier)
创建线程局部变量。 

Interface Lock（显式锁）

基本介绍

 

Lock实现提供比使用synchronized方法和语句可以获得的更广泛的锁定操作。 它们允许更灵活的结构化，可能具有完全不同的属性，并且可以支持多个相关联的对象Condition 。

锁是用于通过多个线程控制对共享资源的访问的工具。 通常，锁提供对共享资源的独占访问：一次只能有一个线程可以获取锁，并且对共享资源的所有访问都要求首先获取锁。 但是，一些锁可能允许并发访问共享资源，如ReadWriteLock的读锁。

使用synchronized方法或语句提供对与每个对象相关联的隐式监视器锁的访问，但是强制所有锁获取和释放以块结构的方式发生：当获取多个锁时，它们必须以相反的顺序被释放，并且所有的锁都必须被释放在与它们相同的词汇范围内。

虽然synchronized方法和语句的范围机制使得使用监视器锁更容易编程，并且有助于避免涉及锁的许多常见编程错误，但是有时您需要以更灵活的方式处理锁。 例如，用于遍历并发访问的数据结构的一些算法需要使用“手动”或“链锁定”：您获取节点A的锁定，然后获取节点B，然后释放A并获取C，然后释放B并获得D等。 所述的实施方式中Lock接口通过允许获得并在不同的范围释放的锁，并允许获得并以任何顺序释放多个锁使得能够使用这样的技术。

随着这种增加的灵活性，额外的责任。 没有块结构化锁定会删除使用synchronized方法和语句发生的锁的自动释放。 在大多数情况下，应使用以下惯用语：

   Lock l = ...; l.lock(); try { // access the resource protected by this lock } finally { l.unlock(); }
当在不同范围内发生锁定和解锁时，必须注意确保在锁定时执行的所有代码由try-finally或try-catch保护，以确保在必要时释放锁定。

Lock实现提供了使用synchronized方法和语句的附加功能，通过提供非阻塞尝试来获取锁（ tryLock() ），尝试获取可被中断的锁（ lockInterruptibly()） ，以及尝试获取可以超时（ tryLock(long, TimeUnit) ）。

一个Lock类还可以提供与隐式监视锁定的行为和语义完全不同的行为和语义，例如保证排序，非重入使用或死锁检测。 如果一个实现提供了这样的专门的语义，那么实现必须记录这些语义。

请注意， Lock实例只是普通对象，它们本身可以用作synchronized语句中的目标。 获取Lock实例的监视器锁与调用该实例的任何lock()方法没有特定关系。 建议为避免混淆，您不要以这种方式使用Lock实例，除了在自己的实现中。

除非另有说明，传递任何参数的null值将导致NullPointerException被抛出。

 

所有已知实现类：

 

ReentrantLock ， ReentrantReadWriteLock.ReadLock ， ReentrantReadWriteLock.WriteLock

基本方法:

void lock()
获得锁。
void lockInterruptibly()
获取锁定，除非当前线程是 interrupted 。
Condition newCondition()
返回一个新Condition绑定到该实例Lock实例。
boolean tryLock()
只有在调用时才可以获得锁。
boolean tryLock(long time, TimeUnit unit)
如果在给定的等待时间内是空闲的，并且当前的线程尚未得到 interrupted，则获取该锁。
void unlock()
释放锁。 

Class ReentrantLock

基本介绍

一个可重入互斥Lock具有与使用synchronized方法和语句访问的隐式监视锁相同的基本行为和语义，但具有扩展功能。

基本方法:

int getHoldCount()
查询当前线程对此锁的暂停数量。
protected Thread getOwner()
返回当前拥有此锁的线程，如果不拥有，则返回 null 。
protected Collection<Thread> getQueuedThreads()
返回包含可能正在等待获取此锁的线程的集合。
int getQueueLength()
返回等待获取此锁的线程数的估计。
protected Collection<Thread> getWaitingThreads(Condition condition)
返回包含可能在与此锁相关联的给定条件下等待的线程的集合。
int getWaitQueueLength(Condition condition)
返回与此锁相关联的给定条件等待的线程数的估计。
boolean hasQueuedThread(Thread thread)
查询给定线程是否等待获取此锁。
boolean hasQueuedThreads()
查询是否有线程正在等待获取此锁。
boolean hasWaiters(Condition condition)
查询任何线程是否等待与此锁相关联的给定条件。
boolean isFair()
如果此锁的公平设置为true，则返回 true 。
boolean isHeldByCurrentThread()
查询此锁是否由当前线程持有。
boolean isLocked()
查询此锁是否由任何线程持有。
void lock()
获得锁。(类似synchronized关键字)
void lockInterruptibly()
获取锁定，除非当前线程是 interrupted 。
Condition newCondition()
返回Condition用于这种用途实例Lock实例。
String toString()
返回一个标识此锁的字符串以及其锁定状态。
boolean tryLock()
只有在调用时它不被另一个线程占用才能获取锁。
boolean tryLock(long timeout, TimeUnit unit)
如果在给定的等待时间内没有被另一个线程 占用 ，并且当前线程尚未被 保留，则获取该锁（ interrupted） 。
void unlock()
尝试释放此锁。 (一般在finally语句执行)

Interface Condition

基本介绍

Condition因素出Object监视器方法（ wait ， notify和notifyAll ）成不同的对象，以得到具有多个等待集的每个对象，通过将它们与使用任意的组合的效果Lock个实现。 Lock替换synchronized方法和语句的使用， Condition取代了对象监视器方法的使用。

条件（也称为条件队列或条件变量 ）为一个线程暂停执行（“等待”）提供了一种方法，直到另一个线程通知某些状态现在可能为真。 因为访问此共享状态信息发生在不同的线程中，所以它必须被保护，因此某种形式的锁与该条件相关联。 等待条件的关键属性是它原子地释放相关的锁并挂起当前线程，就像Object.wait 。

一个Condition实例本质上绑定到一个锁。 要获得特定Condition实例的Condition实例，请使用其newCondition()方法。

基本方法:

void await()
导致当前线程等到发信号或 interrupted 。
boolean await(long time, TimeUnit unit)
使当前线程等待直到发出信号或中断，或指定的等待时间过去。
long awaitNanos(long nanosTimeout)
使当前线程等待直到发出信号或中断，或指定的等待时间过去。
void awaitUninterruptibly()
使当前线程等待直到发出信号。
boolean awaitUntil(Date deadline)
使当前线程等待直到发出信号或中断，或者指定的最后期限过去。
void signal()
唤醒一个等待线程。
void signalAll()
唤醒所有等待线程。 

Interface ReadWriteLock（读写分离锁的抽象）

基本介绍:

ReadWriteLock维护一对关联的locks ，一个用于只读操作，一个用于写入。 read lock可以由多个阅读器线程同时进行

基本方法:

Lock readLock()
返回用于阅读的锁。
Lock writeLock()
返回用于写入的锁。 

Class ReentrantReadWriteLock（读写分离锁）

基本介绍

  • 实现支持类似的语义到ReentrantLock 。
  • ReentrantReadWriteLock 读写锁是一种改进的排他锁,也可以称作共享/排他锁.
  • 允许多个线程同时读取共享数据,但是一次只允许一个线程对共享数据进行更新.读写锁通过读锁与写锁来完成读写操作.
  • 线程在读取共享数据前必须先持有读锁,该读锁可以同时被多个线程持有,即它是共享的.
  • 线程在修改共享数据前必须先持有写锁,写锁是排他的, 一个线程持有写锁时其他线程无法获得相应的锁读锁只是在读线程之间共享
  • 任何一个线程持有读锁时,其他线程都无法获得写锁, 保证线程在读取数据期间没有其他线程对数据进行更新,使得读线程能够读到数据的最新值,保证在读数据期间共享变量不被修改 

　　读写互斥，读读共享，写写互斥

基本方法:

静态方法:

static class  ReentrantReadWriteLock.ReadLock
该锁由方法 readLock()返回。
static class  ReentrantReadWriteLock.WriteLock
该锁由方法 writeLock()返回。  

实例方法:

protected Thread getOwner()
返回当前拥有写锁的线程，如果不拥有，则返回 null 。
protected Collection<Thread> getQueuedReaderThreads()
返回一个包含可能正在等待获取读取锁的线程的集合。
protected Collection<Thread> getQueuedThreads()
返回一个包含可能正在等待获取读取或写入锁定的线程的集合。
protected Collection<Thread> getQueuedWriterThreads()
返回一个包含可能正在等待获取写入锁的线程的集合。
int getQueueLength()
返回等待获取读取或写入锁定的线程数的估计。
int getReadHoldCount()
查询当前线程对此锁的可重入读取保留数。
int getReadLockCount()
查询为此锁持有的读取锁的数量。
protected Collection<Thread> getWaitingThreads(Condition condition)
返回包含可能在与写锁相关联的给定条件下等待的线程的集合。
int getWaitQueueLength(Condition condition)
返回与写入锁相关联的给定条件等待的线程数的估计。
int getWriteHoldCount()
查询当前线程对此锁的可重入写入数量。
boolean hasQueuedThread(Thread thread)
查询给定线程是否等待获取读取或写入锁定。
boolean hasQueuedThreads()
查询是否有任何线程正在等待获取读取或写入锁定。
boolean hasWaiters(Condition condition)
查询任何线程是否等待与写锁相关联的给定条件。
boolean isFair()
如果此锁的公平设置为true，则返回 true 。
boolean isWriteLocked()
查询写锁是否由任何线程持有。
boolean isWriteLockedByCurrentThread()
查询写锁是否由当前线程持有。
ReentrantReadWriteLock.ReadLock readLock()
返回用于阅读的锁。
String toString()
返回一个标识此锁的字符串以及其锁定状态。
ReentrantReadWriteLock.WriteLock writeLock()
返回用于写入的锁。 

 

Interface Executor

基本介绍:

执行提交的对象Runnable任务。 该界面提供了一种将任务提交从每个任务的运行机制分解的方式，包括线程使用，调度等的Executor 。通常使用Executor而不是显式创建线程。

基本方法:

void execute(Runnable command)
在将来的某个时间执行给定的命令。 

Class ThreadPoolExecutor（普通任务）

基本介绍:

  • 一个ExecutorService ，使用可能的几个合并的线程执行每个提交的任务，通常使用Executors工厂方法配置。
  • 线程池解决两个不同的问题：由于每个任务的调用开销减少，它们通常在执行大量异步任务时提供改进的性能，并且它们提供了一种限制和管理资源（包括执行一个任务。 每个ThreadPoolExecutor还维护一些基本统计信息，例如已完成任务的数量。

基本方法:

构造方法:

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue)
创建一个新的 ThreadPoolExecutor与给定的初始参数和默认线程工厂和拒绝执行处理程序。
ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler)
创建一个新的 ThreadPoolExecutor与给定的初始参数和默认线程工厂。
ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory)
创建一个新的 ThreadPoolExecutor与给定的初始参数和默认拒绝执行处理程序。
ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)
创建一个新 ThreadPoolExecutor给定的初始参数。 

静态方法:

static class  ThreadPoolExecutor.AbortPolicy
被拒绝的任务的处理程序，抛出一个 RejectedExecutionException 。
static class  ThreadPoolExecutor.CallerRunsPolicy
一个被拒绝的任务的处理程序，直接在 execute方法的调用线程中运行被拒绝的任务，除非执行程序已经被关闭，否则这个任务被丢弃。
static class  ThreadPoolExecutor.DiscardOldestPolicy
被拒绝的任务的处理程序，丢弃最旧的未处理请求，然后重试 execute ，除非执行程序关闭，在这种情况下，任务被丢弃。
static class  ThreadPoolExecutor.DiscardPolicy
被拒绝的任务的处理程序静默地丢弃被拒绝的任务。 

实例方法:

protected void afterExecute(Runnable r, Throwable t)
完成指定Runnable的执行后调用方法。
void allowCoreThreadTimeOut(boolean value)
设置策略是否核心线程可能会超时，如果任务没有在活着的时间内到达，则在新任务到达时被替换。
boolean allowsCoreThreadTimeOut()
如果此池允许核心线程超时并终止，如果没有任务在keepAlive时间内到达，则返回true，如果新任务到达时需要更换。
boolean awaitTermination(long timeout, TimeUnit unit)
阻止所有任务在关闭请求完成后执行，或发生超时，或当前线程中断，以先到者为准。
protected void beforeExecute(Thread t, Runnable r)
在给定的线程中执行给定的Runnable之前调用方法。
void execute(Runnable command)
在将来某个时候执行给定的任务。
protected void finalize()
当这个执行器不再被引用并且没有线程时，调用 shutdown 。
int getActiveCount()
返回正在执行任务的线程的大概数量。
long getCompletedTaskCount()
返回完成执行的任务的大致总数。
int getCorePoolSize()
返回核心线程数。
long getKeepAliveTime(TimeUnit unit)
返回线程保持活动时间，这是超过核心池大小的线程在终止之前可能保持空闲的时间量。
int getLargestPoolSize()
返回在池中同时进行的最大线程数。
int getMaximumPoolSize()
返回允许的最大线程数。
int getPoolSize()
返回池中当前的线程数。
BlockingQueue<Runnable> getQueue()
返回此执行程序使用的任务队列。
RejectedExecutionHandler getRejectedExecutionHandler()
返回不可执行任务的当前处理程序。
long getTaskCount()
返回计划执行的任务的大概总数。
ThreadFactory getThreadFactory()
返回用于创建新线程的线程工厂。
boolean isShutdown()
如果此执行者已关闭，则返回 true 。
boolean isTerminated()
如果所有任务在关闭后完成，则返回 true 。
boolean isTerminating()
如果此执行者在 shutdown()或 shutdownNow()之后 终止 ，但尚未完全终止，则返回true。
int prestartAllCoreThreads()
启动所有核心线程，导致他们等待工作。
boolean prestartCoreThread()
启动核心线程，使其无法等待工作。
void purge()
尝试从工作队列中删除已取消的所有Future任务。
boolean remove(Runnable task)
如果此任务存在，则从执行程序的内部队列中删除此任务，从而导致该任务尚未运行。
void setCorePoolSize(int corePoolSize)
设置核心线程数。
void setKeepAliveTime(long time, TimeUnit unit)
设置线程在终止之前可能保持空闲的时间限制。
void setMaximumPoolSize(int maximumPoolSize)
设置允许的最大线程数。
void setRejectedExecutionHandler(RejectedExecutionHandler handler)
为不可执行的任务设置一个新的处理程序。
void setThreadFactory(ThreadFactory threadFactory)
设置用于创建新线程的线程工厂。
void shutdown()
启动有序关闭，其中先前提交的任务将被执行，但不会接受任何新任务。
List<Runnable> shutdownNow()
尝试停止所有主动执行的任务，停止等待任务的处理，并返回正在等待执行的任务列表。
protected void terminated()
执行程序已终止时调用方法。
String toString()
返回标识此池的字符串及其状态，包括运行状态和估计的工作人员和任务计数的指示。 

Class ScheduledThreadPoolExecutor（专门做定时任务）

基本介绍:

ThreadPoolExecutor可另外调度在给定延迟之后运行的命令，或定期执行。 该类优选的是Timer需要多个工作线程时，或当附加灵活性或能力ThreadPoolExecutor需要（这此类扩展）。

延迟任务执行时间早于启用，但没有任何实时保证，在启用后，他们将开始。 计划执行完全相同执行时间的任务将以先进先出（FIFO）的提交顺序启用。

提交的任务在运行之前被取消，执行被抑制。 默认情况下，这样一个取消的任务在工作队列中不会自动删除，直到其延迟过去。 虽然这样可以进一步检查和监控，但也可能导致取消任务的无限制保留。 为避免这种情况，请将setRemoveOnCancelPolicy(boolean)设置为true ，这将导致任务在取消时立即从工作队列中删除。

通过scheduleAtFixedRate或scheduleWithFixedDelay的任务的scheduleWithFixedDelay执行不重叠。 虽然不同的执行可以通过不同的线程来执行，先前执行的效果happen-before那些随后的那些的。

虽然这个类继承自ThreadPoolExecutor ，但是一些继承的调优方法对它没有用。 特别是因为它作为使用corePoolSize线程和无限队列的固定大小的池，对maximumPoolSize没有任何有用的效果。 此外，将corePoolSize设置为零或使用allowCoreThreadTimeOut几乎不是一个好主意，因为这可能会使池没有线程来处理任务，只要它们有资格运行。

此类覆盖execute和submit方法以生成内部ScheduledFuture对象来控制每个任务的延迟和调度。 为了保护功能，子类中这些方法的任何进一步覆盖都必须调用超类版本，这有效地禁用其他任务自定义。 然而，此类提供替代保护扩展方法decorateTask （每一个用于一个版本Runnable和Callable ），其可以被用于定制用于执行经由输入的命令的具体任务类型execute ， submit ， schedule ， scheduleAtFixedRate和scheduleWithFixedDelay 。 默认情况下， ScheduledThreadPoolExecutor使用扩展为FutureTask的任务类型。 但是，可以使用以下形式的子类修改或替换：

基本方法:

构造方法:

ScheduledThreadPoolExecutor(int corePoolSize)
创建一个新的 ScheduledThreadPoolExecutor与给定的核心池大小。
ScheduledThreadPoolExecutor(int corePoolSize, RejectedExecutionHandler handler)
使用给定的初始参数创建一个新的ScheduledThreadPoolExecutor。
ScheduledThreadPoolExecutor(int corePoolSize, ThreadFactory threadFactory)
创建一个新的 ScheduledThreadPoolExecutor与给定的初始参数。
ScheduledThreadPoolExecutor(int corePoolSize, ThreadFactory threadFactory, RejectedExecutionHandler handler)
使用给定的初始参数创建一个新的ScheduledThreadPoolExecutor。 

实例方法:

protected <V> RunnableScheduledFuture<V> decorateTask(Callable<V> callable, RunnableScheduledFuture<V> task)
修改或替换用于执行可调用的任务。
protected <V> RunnableScheduledFuture<V> decorateTask(Runnable runnable, RunnableScheduledFuture<V> task)
修改或替换用于执行runnable的任务。
void execute(Runnable command)
执行 command零要求延迟。
boolean getContinueExistingPeriodicTasksAfterShutdownPolicy()
获得关于是否继续执行现有定期任务的策略，即使该执行者已经是 shutdown 。
boolean getExecuteExistingDelayedTasksAfterShutdownPolicy()
获得有关是否执行现有延迟任务的政策，即使这个执行者已经是 shutdown 。
BlockingQueue<Runnable> getQueue()
返回此执行程序使用的任务队列。
boolean getRemoveOnCancelPolicy()
获取关于在取消时是否应立即将已取消任务从工作队列中删除的策略。
<V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit)
创建并执行在给定延迟后启用的ScheduledFuture。
ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit)
创建并执行在给定延迟后启用的单次操作。
ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)
创建并执行在给定的初始延迟之后，随后以给定的时间段首先启用的周期性动作; 那就是执行将在initialDelay之后开始，然后initialDelay+period ，然后是initialDelay + 2 * period等等。
ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)
创建并执行在给定的初始延迟之后首先启用的定期动作，随后在一个执行的终止和下一个执行的开始之间给定的延迟。
void setContinueExistingPeriodicTasksAfterShutdownPolicy(boolean value)
设置关于是否继续执行现有周期性任务的策略，即使该执行者已经是 shutdown 。
void setExecuteExistingDelayedTasksAfterShutdownPolicy(boolean value)
设置关于是否执行现有延迟任务的策略，即使该执行者已经是 shutdown 。
void setRemoveOnCancelPolicy(boolean value)
设置取消时取消任务是否应立即从工作队列中删除的策略。
void shutdown()
启动有序关闭，其中先前提交的任务将被执行，但不会接受任何新任务。
List<Runnable> shutdownNow()
尝试停止所有主动执行的任务，停止等待任务的处理，并返回正在等待执行的任务列表。
<T> Future<T> submit(Callable<T> task)
提交值返回任务以执行，并返回代表任务待处理结果的Future。
Future<?> submit(Runnable task)
提交一个可运行的任务执行，并返回一个表示该任务的未来。
<T> Future<T> submit(Runnable task, T result)
提交一个可运行的任务执行，并返回一个表示该任务的未来。 

 

阻塞队列

JDK7 提供了 7 个阻塞队列。分别是

  • ArrayBlockingQueue ：一个由数组结构组成的有界阻塞队列。
  • LinkedBlockingQueue ：一个由链表结构组成的有界阻塞队列。
  • PriorityBlockingQueue ：一个支持优先级排序的无界阻塞队列。
  • DelayQueue：一个使用优先级队列实现的无界阻塞队列。
  • SynchronousQueue：一个不存储元素的阻塞队列。
  • LinkedTransferQueue：一个由链表结构组成的无界阻塞队列。
  • LinkedBlockingDeque：一个由链表结构组成的双向阻塞队列

具体方法参照Collection接口的各个实现类

Interface Callable<V>

基本介绍:

返回结果并可能引发异常的任务。 实现者定义一个没有参数的单一方法，称为call 。

Callable接口类似于Runnable ，因为它们都是为其实例可能由另一个线程执行的类设计的。 然而，A Runnable不返回结果，也不能抛出被检查的异常。

基本方法:

V call()
计算一个结果，如果不能这样做，就会抛出一个异常。 

FutureTask包装器可以将Callable转换成Future和Runable(Future同时实现了两者的接口)

Interface Future<V>　

基本介绍:

Future计算的结果。 提供方法来检查计算是否完成，等待其完成，并检索计算结果。 结果只能在计算完成后使用方法get进行检索，如有必要，阻塞，直到准备就绪。 取消由cancel方法执行。 提供其他方法来确定任务是否正常完成或被取消。 计算完成后，不能取消计算。 如果您想使用Future ，以便不可撤销，但不提供可用的结果，则可以声明Future<?>表格的类型，并返回null作为基础任务的结果。

基本方法:

boolean cancel(boolean mayInterruptIfRunning)
尝试取消执行此任务。
V get()
等待计算完成，然后检索其结果。
V get(long timeout, TimeUnit unit)
如果需要等待最多在给定的时间计算完成，然后检索其结果（如果可用）。
boolean isCancelled()
如果此任务在正常完成之前被取消，则返回 true 。
boolean isDone()
返回 true如果任务已完成。 

 

 

 代码示例:

 1 package com.edu.future_callable;
 2 
 3 import java.util.concurrent.Callable;
 4 import java.util.concurrent.Future;
 5 import java.util.concurrent.FutureTask;
 6 import java.util.concurrent.TimeUnit;
 7 
 8 /**
 9  * @作者 five-five
10  * @创建时间 2020/10/7
11  */
12 public class FutureTest{
13     public static void main(String[] args){
14         //这里用的是Callable
15         FutureTask<Integer> futureTask = new FutureTask<Integer>(()->{
16             TimeUnit.SECONDS.sleep(2);
17             Integer res=Integer.valueOf((int) (Math.random()*1000));
18             System.out.println(Math.random()*1000+String.class.hashCode());
19             return res;
20         });
21         System.out.println("搞完了？=="+futureTask.isDone());
22         futureTask.run();
23         System.out.println("搞完了？=="+futureTask.isDone());
24         System.out.println("结束了？=="+futureTask.isCancelled());
25 
26         System.out.println("=========================================================");
27         //这个是Runnable
28         Runnable r=new Runnable(){
29             @Override
30             public void run() {
31                 try {
32                     TimeUnit.SECONDS.sleep(2);
33                 } catch (InterruptedException e) {
34                     e.printStackTrace();
35                 }
36                 Integer res=Integer.valueOf((int) (Math.random()*1000));
37                 System.out.println(Math.random()*1000+String.class.hashCode());
38             }
39         };
40         Integer num = null;
41         FutureTask<Integer> futureTask1 = new FutureTask<Integer>(r,num);
42         System.out.println("搞完了？=="+futureTask1.isDone());
43         futureTask1.run();
44         System.out.println("搞完了？=="+futureTask1.isDone());
45         System.out.println("结束了？=="+futureTask1.isCancelled());
46 
47     }
48 }

 

posted @ 2020-10-07 12:05  揸火箭  阅读(176)  评论(0)  编辑  收藏  举报

Loading