程序包 org.apache.dubbo.common.threadpool

类 ThreadlessExecutor

java.lang.Object

java.util.concurrent.AbstractExecutorService

org.apache.dubbo.common.threadpool.ThreadlessExecutor

所有已实现的接口:

Executor, ExecutorService

public class ThreadlessExecutor
extends AbstractExecutorService

The most important difference between this Executor and other normal Executor is that this one doesn't manage any thread.

Tasks submitted to this executor through execute(Runnable) will not get scheduled to a specific thread, though normal executors always do the schedule. Those tasks are stored in a blocking queue and will only be executed when a thread calls waitAndDrain(), the thread executing the task is exactly the same as the one calling waitAndDrain.

构造器概要

构造器

构造器	说明
ThreadlessExecutor(ExecutorService sharedExecutor)

方法概要

修饰符和类型	方法	说明
boolean	awaitTermination(long timeout, TimeUnit unit)
void	execute(Runnable runnable)	If the calling thread is still waiting for a callback task, add the task into the blocking queue to wait for schedule.
CompletableFuture<?>	getWaitingFuture()
boolean	isShutdown()
boolean	isTerminated()
boolean	isWaiting()
void	notifyReturn(Throwable t)	tells the thread blocking on waitAndDrain() to return, despite of the current status, to avoid endless waiting.
void	setWaitingFuture(CompletableFuture<?> waitingFuture)
void	shutdown()	The following methods are still not supported
List<Runnable>	shutdownNow()
void	waitAndDrain()	Waits until there is a task, executes the task and all queued tasks (if there're any).
long	waitAndDrain(long timeout, TimeUnit unit)

从类继承的方法 java.util.concurrent.AbstractExecutorService

invokeAll, invokeAll, invokeAny, invokeAny, submit, submit, submit

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

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

构造器详细资料

ThreadlessExecutor

public ThreadlessExecutor(ExecutorService sharedExecutor)

方法详细资料

getWaitingFuture

public CompletableFuture<?> getWaitingFuture()

setWaitingFuture

public void setWaitingFuture(CompletableFuture<?> waitingFuture)

isWaiting

public boolean isWaiting()

waitAndDrain

public void waitAndDrain()
                  throws InterruptedException

Waits until there is a task, executes the task and all queued tasks (if there're any). The task is either a normal response or a timeout response.

抛出:

InterruptedException

waitAndDrain

public long waitAndDrain(long timeout,
                         TimeUnit unit)
                  throws InterruptedException,
                         TimeoutException

抛出:

InterruptedException

TimeoutException

execute

public void execute(Runnable runnable)

If the calling thread is still waiting for a callback task, add the task into the blocking queue to wait for schedule. Otherwise, submit to shared callback executor directly.

参数:

runnable -

notifyReturn

public void notifyReturn(Throwable t)

tells the thread blocking on waitAndDrain() to return, despite of the current status, to avoid endless waiting.

shutdown

public void shutdown()

The following methods are still not supported

shutdownNow

public List<Runnable> shutdownNow()

isShutdown

public boolean isShutdown()

isTerminated

public boolean isTerminated()

awaitTermination

public boolean awaitTermination(long timeout,
                                TimeUnit unit)
                         throws InterruptedException

抛出:

InterruptedException