mirror of https://github.com/longtai-cn/hippo4j
huangchengxing
3 years ago
parent
03ea6668af
commit
824afc4da3
@ -0,0 +1,142 @@
|
||||
/*
|
||||
* 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 cn.hippo4j.common.toolkit;
|
||||
|
||||
import lombok.Getter;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
|
||||
import java.util.concurrent.locks.Lock;
|
||||
import java.util.concurrent.locks.ReadWriteLock;
|
||||
import java.util.concurrent.locks.ReentrantReadWriteLock;
|
||||
|
||||
/**
|
||||
* Thread safe time recorder,
|
||||
* used to record multiple time periods and count various time indicators.
|
||||
*
|
||||
* @author huangchengxing
|
||||
*/
|
||||
public class SyncTimeRecorder {
|
||||
|
||||
/**
|
||||
* Lock instance.
|
||||
*/
|
||||
private final ReadWriteLock lock = new ReentrantReadWriteLock();
|
||||
|
||||
/**
|
||||
* Total execution milli time of all tasks.
|
||||
*/
|
||||
private long totalTaskTime = 0L;
|
||||
|
||||
/**
|
||||
* Maximum task milli execution time, default -1.
|
||||
*/
|
||||
private long maxTaskTime = -1L;
|
||||
|
||||
/**
|
||||
* Minimal task milli execution time, default -1.
|
||||
*/
|
||||
private long minTaskTime = -1L;
|
||||
|
||||
/**
|
||||
* Count of completed task.
|
||||
*/
|
||||
private long taskCount = 0L;
|
||||
|
||||
/**
|
||||
* Get the summary statistics of the instance at the current time.
|
||||
*
|
||||
* @return data snapshot
|
||||
*/
|
||||
public Summary summarize() {
|
||||
Lock readLock = lock.readLock();
|
||||
Summary statistics;
|
||||
readLock.lock();
|
||||
try {
|
||||
statistics = new Summary(
|
||||
this.totalTaskTime,
|
||||
this.maxTaskTime,
|
||||
this.minTaskTime,
|
||||
this.taskCount);
|
||||
} finally {
|
||||
readLock.unlock();
|
||||
}
|
||||
return statistics;
|
||||
}
|
||||
|
||||
/**
|
||||
* Refresh time indicators of the current instance.
|
||||
*
|
||||
* @param taskExecutionTime millisecond
|
||||
*/
|
||||
public final void refreshTime(long taskExecutionTime) {
|
||||
Lock writeLock = lock.writeLock();
|
||||
writeLock.lock();
|
||||
try {
|
||||
if (taskCount == 0) {
|
||||
maxTaskTime = taskExecutionTime;
|
||||
minTaskTime = taskExecutionTime;
|
||||
} else {
|
||||
maxTaskTime = Math.max(taskExecutionTime, maxTaskTime);
|
||||
minTaskTime = Math.min(taskExecutionTime, minTaskTime);
|
||||
}
|
||||
taskCount = taskCount + 1;
|
||||
totalTaskTime += taskExecutionTime;
|
||||
} finally {
|
||||
writeLock.unlock();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Summary statistics of SyncTimeRecorder instance at a certain time.
|
||||
*/
|
||||
@Getter
|
||||
@RequiredArgsConstructor
|
||||
public static class Summary {
|
||||
|
||||
/**
|
||||
* Total execution nano time of all tasks.
|
||||
*/
|
||||
private final long totalTaskTime;
|
||||
|
||||
/**
|
||||
* Maximum task nano execution time.
|
||||
*/
|
||||
private final long maxTaskTime;
|
||||
|
||||
/**
|
||||
* Minimal task nano execution time.
|
||||
*/
|
||||
private final long minTaskTime;
|
||||
|
||||
/**
|
||||
* Count of completed task.
|
||||
*/
|
||||
private final long taskCount;
|
||||
|
||||
/**
|
||||
* Get the avg task time in milliseconds.
|
||||
*
|
||||
* @return avg task time
|
||||
*/
|
||||
public long getAvgTaskTimeMillis() {
|
||||
return getMinTaskTime() / getTaskCount();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,309 @@
|
||||
/*
|
||||
* 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 cn.hippo4j.core.executor;
|
||||
|
||||
import cn.hippo4j.core.plugin.*;
|
||||
import lombok.AllArgsConstructor;
|
||||
import lombok.Getter;
|
||||
import lombok.NonNull;
|
||||
import lombok.Setter;
|
||||
|
||||
import java.util.Collection;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.*;
|
||||
|
||||
/**
|
||||
* <p>Extensible thread-pool executor. <br />
|
||||
* Support the callback extension points provided on the basis of {@link ThreadPoolExecutor}.
|
||||
* Each extension point corresponds to a different {@link ThreadPoolPlugin} interface,
|
||||
* users can customize plug-ins and implement one or more {@link ThreadPoolPlugin} interface
|
||||
* to enable plugins to sense thread pool behavior and provide extended functions.
|
||||
*
|
||||
* @author huangchengxing
|
||||
*/
|
||||
public class ExtensibleThreadPoolExecutor
|
||||
extends ThreadPoolExecutor implements ThreadPoolPluginRegistryDelegate {
|
||||
|
||||
/**
|
||||
* thread pool id
|
||||
*/
|
||||
@Getter
|
||||
@NonNull
|
||||
private final String threadPoolId;
|
||||
|
||||
/**
|
||||
* action aware registry
|
||||
*/
|
||||
@Getter
|
||||
private final ThreadPoolPluginRegistry threadPoolPluginRegistry;
|
||||
|
||||
/**
|
||||
* handler wrapper, any changes to the current instance {@link RejectedExecutionHandler} should be made through this wrapper
|
||||
*/
|
||||
private final RejectedAwareHandlerWrapper handlerWrapper;
|
||||
|
||||
/**
|
||||
* Creates a new {@code ExtensibleThreadPoolExecutor} with the given initial parameters.
|
||||
*
|
||||
* @param threadPoolId thread-pool id
|
||||
* @param threadPoolPluginRegistry action aware registry
|
||||
* @param corePoolSize the number of threads to keep in the pool, even
|
||||
* if they are idle, unless {@code allowCoreThreadTimeOut} is set
|
||||
* @param maximumPoolSize the maximum number of threads to allow in the
|
||||
* pool
|
||||
* @param keepAliveTime when the number of threads is greater than
|
||||
* the core, this is the maximum time that excess idle threads
|
||||
* will wait for new tasks before terminating.
|
||||
* @param unit the time unit for the {@code keepAliveTime} argument
|
||||
* @param workQueue the queue to use for holding tasks before they are
|
||||
* executed. This queue will hold only the {@code Runnable}
|
||||
* tasks submitted by the {@code execute} method.
|
||||
* @param threadFactory the factory to use when the executor
|
||||
* creates a new thread
|
||||
* @param handler the handler to use when execution is blocked
|
||||
* because the thread bounds and queue capacities are reached
|
||||
* @throws IllegalArgumentException if one of the following holds:<br>
|
||||
* {@code corePoolSize < 0}<br>
|
||||
* {@code keepAliveTime < 0}<br>
|
||||
* {@code maximumPoolSize <= 0}<br>
|
||||
* {@code maximumPoolSize < corePoolSize}
|
||||
* @throws NullPointerException if {@code workQueue}
|
||||
* or {@code threadFactory} or {@code handler} is null
|
||||
*/
|
||||
public ExtensibleThreadPoolExecutor(
|
||||
@NonNull String threadPoolId,
|
||||
@NonNull ThreadPoolPluginRegistry threadPoolPluginRegistry,
|
||||
int corePoolSize, int maximumPoolSize,
|
||||
long keepAliveTime, TimeUnit unit,
|
||||
@NonNull BlockingQueue<Runnable> workQueue,
|
||||
@NonNull ThreadFactory threadFactory,
|
||||
@NonNull RejectedExecutionHandler handler) {
|
||||
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
|
||||
|
||||
// pool extended info
|
||||
this.threadPoolId = threadPoolId;
|
||||
this.threadPoolPluginRegistry = threadPoolPluginRegistry;
|
||||
|
||||
// proxy handler to support Aware callback
|
||||
while (handler instanceof RejectedAwareHandlerWrapper) {
|
||||
handler = ((RejectedAwareHandlerWrapper) handler).getHandler();
|
||||
}
|
||||
this.handlerWrapper = new RejectedAwareHandlerWrapper(threadPoolPluginRegistry, handler);
|
||||
super.setRejectedExecutionHandler(handlerWrapper);
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* <p><b>Before calling the parent class method, {@link ExecuteAwarePlugin#beforeExecute} will be called first.
|
||||
*
|
||||
* @param thread the thread that will run task {@code r}
|
||||
* @param runnable the task that will be executed
|
||||
*/
|
||||
@Override
|
||||
protected void beforeExecute(Thread thread, Runnable runnable) {
|
||||
Collection<ExecuteAwarePlugin> executeAwarePluginList = threadPoolPluginRegistry.getExecuteAwareList();
|
||||
executeAwarePluginList.forEach(aware -> aware.beforeExecute(thread, runnable));
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* <p><b>Before calling the parent class method, {@link ExecuteAwarePlugin#execute} will be called first.
|
||||
*
|
||||
* @param runnable the task to execute
|
||||
*/
|
||||
@Override
|
||||
public void execute(@NonNull Runnable runnable) {
|
||||
Collection<ExecuteAwarePlugin> executeAwarePluginList = threadPoolPluginRegistry.getExecuteAwareList();
|
||||
for (ExecuteAwarePlugin executeAwarePlugin : executeAwarePluginList) {
|
||||
runnable = executeAwarePlugin.execute(runnable);
|
||||
}
|
||||
super.execute(runnable);
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* <p><b>After calling the parent class method, {@link ExecuteAwarePlugin#afterExecute} will be called last.
|
||||
*
|
||||
* @param runnable the runnable that has completed
|
||||
* @param throwable the exception that caused termination, or null if
|
||||
* execution completed normally
|
||||
*/
|
||||
@Override
|
||||
protected void afterExecute(Runnable runnable, Throwable throwable) {
|
||||
Collection<ExecuteAwarePlugin> executeAwarePluginList = threadPoolPluginRegistry.getExecuteAwareList();
|
||||
executeAwarePluginList.forEach(aware -> aware.afterExecute(runnable, throwable));
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* <p><b>Before calling the parent class method,
|
||||
* {@link ShutdownAwarePlugin#beforeShutdown} will be called first.
|
||||
* and then will be call {@link ShutdownAwarePlugin#afterShutdown}
|
||||
*
|
||||
* @throws SecurityException {@inheritDoc}
|
||||
*/
|
||||
@Override
|
||||
public void shutdown() {
|
||||
Collection<ShutdownAwarePlugin> shutdownAwarePluginList = threadPoolPluginRegistry.getShutdownAwareList();
|
||||
shutdownAwarePluginList.forEach(aware -> aware.beforeShutdown(this));
|
||||
super.shutdown();
|
||||
shutdownAwarePluginList.forEach(aware -> aware.afterShutdown(this, Collections.emptyList()));
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* <p><b>Before calling the parent class method,
|
||||
* {@link ShutdownAwarePlugin#beforeShutdown} will be called first.
|
||||
* and then will be call {@link ShutdownAwarePlugin#afterShutdown}
|
||||
*
|
||||
* @throws SecurityException
|
||||
*/
|
||||
@Override
|
||||
public List<Runnable> shutdownNow() {
|
||||
Collection<ShutdownAwarePlugin> shutdownAwarePluginList = threadPoolPluginRegistry.getShutdownAwareList();
|
||||
shutdownAwarePluginList.forEach(aware -> aware.beforeShutdown(this));
|
||||
List<Runnable> tasks = super.shutdownNow();
|
||||
shutdownAwarePluginList.forEach(aware -> aware.afterShutdown(this, tasks));
|
||||
return tasks;
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}.
|
||||
*
|
||||
* <p><b>Before calling the parent class method, {@link ShutdownAwarePlugin#afterTerminated} will be called first.
|
||||
*/
|
||||
@Override
|
||||
protected void terminated() {
|
||||
super.terminated();
|
||||
Collection<ShutdownAwarePlugin> shutdownAwarePluginList = threadPoolPluginRegistry.getShutdownAwareList();
|
||||
shutdownAwarePluginList.forEach(aware -> aware.afterTerminated(this));
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* <p><b>Before calling the parent class method, {@link TaskAwarePlugin#beforeTaskCreate} will be called first.
|
||||
*
|
||||
* @param runnable the runnable task being wrapped
|
||||
* @param value the default value for the returned future
|
||||
* @return a {@code RunnableFuture} which, when run, will run the
|
||||
* underlying runnable and which, as a {@code Future}, will yield
|
||||
* the given value as its result and provide for cancellation of
|
||||
* the underlying task
|
||||
* @since 1.6
|
||||
*/
|
||||
@Override
|
||||
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
|
||||
Collection<TaskAwarePlugin> taskAwarePluginList = threadPoolPluginRegistry.getTaskAwareList();
|
||||
for (TaskAwarePlugin taskAwarePlugin : taskAwarePluginList) {
|
||||
runnable = taskAwarePlugin.beforeTaskCreate(this, runnable, value);
|
||||
}
|
||||
return super.newTaskFor(runnable, value);
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*
|
||||
* <p><b>Before calling the parent class method, {@link TaskAwarePlugin#beforeTaskCreate} will be called first.
|
||||
*
|
||||
* @param callable the callable task being wrapped
|
||||
* @return a {@code RunnableFuture} which, when run, will call the
|
||||
* underlying callable and which, as a {@code Future}, will yield
|
||||
* the callable's result as its result and provide for
|
||||
* cancellation of the underlying task
|
||||
* @since 1.6
|
||||
*/
|
||||
@Override
|
||||
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
|
||||
Collection<TaskAwarePlugin> taskAwarePluginList = threadPoolPluginRegistry.getTaskAwareList();
|
||||
for (TaskAwarePlugin taskAwarePlugin : taskAwarePluginList) {
|
||||
callable = taskAwarePlugin.beforeTaskCreate(this, callable);
|
||||
}
|
||||
return super.newTaskFor(callable);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets a new handler for unexecutable tasks.
|
||||
*
|
||||
* @param handler the new handler
|
||||
* @throws NullPointerException if handler is null
|
||||
* @see #getRejectedExecutionHandler
|
||||
*/
|
||||
@Override
|
||||
public void setRejectedExecutionHandler(@NonNull RejectedExecutionHandler handler) {
|
||||
while (handler instanceof RejectedAwareHandlerWrapper) {
|
||||
handler = ((RejectedAwareHandlerWrapper) handler).getHandler();
|
||||
}
|
||||
handlerWrapper.setHandler(handler);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the current handler for unexecutable tasks.
|
||||
*
|
||||
* @return the current handler
|
||||
* @see #setRejectedExecutionHandler(RejectedExecutionHandler)
|
||||
*/
|
||||
@Override
|
||||
public RejectedExecutionHandler getRejectedExecutionHandler() {
|
||||
return handlerWrapper.getHandler();
|
||||
}
|
||||
|
||||
/**
|
||||
* Wrapper of original {@link RejectedExecutionHandler} of {@link ThreadPoolExecutor},
|
||||
* It's used to support the {@link RejectedAwarePlugin} on the basis of the {@link RejectedExecutionHandler}.
|
||||
*
|
||||
* @author huangchengxing
|
||||
* @see RejectedAwarePlugin
|
||||
*/
|
||||
@AllArgsConstructor
|
||||
public static class RejectedAwareHandlerWrapper implements RejectedExecutionHandler {
|
||||
|
||||
/**
|
||||
* thread-pool action aware registry
|
||||
*/
|
||||
private final ThreadPoolPluginRegistry registry;
|
||||
|
||||
/**
|
||||
* original target
|
||||
*/
|
||||
@NonNull
|
||||
@Setter
|
||||
@Getter
|
||||
private RejectedExecutionHandler handler;
|
||||
|
||||
/**
|
||||
* Call {@link RejectedAwarePlugin#beforeRejectedExecution}, then reject the task
|
||||
*
|
||||
* @param r the runnable task requested to be executed
|
||||
* @param executor the executor attempting to execute this task
|
||||
*/
|
||||
@Override
|
||||
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
|
||||
Collection<RejectedAwarePlugin> rejectedAwarePluginList = registry.getRejectedAwareList();
|
||||
rejectedAwarePluginList.forEach(aware -> aware.beforeRejectedExecution(r, executor));
|
||||
handler.rejectedExecution(r, executor);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,105 @@
|
||||
package cn.hippo4j.core.plugin;
|
||||
|
||||
import cn.hippo4j.core.executor.ExtensibleThreadPoolExecutor;
|
||||
import cn.hippo4j.core.plugin.impl.*;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
import org.springframework.beans.BeansException;
|
||||
import org.springframework.beans.factory.BeanFactoryUtils;
|
||||
import org.springframework.beans.factory.BeanNameAware;
|
||||
import org.springframework.beans.factory.InitializingBean;
|
||||
import org.springframework.context.ApplicationContext;
|
||||
import org.springframework.context.ApplicationContextAware;
|
||||
import org.springframework.core.AliasRegistry;
|
||||
|
||||
import java.util.Objects;
|
||||
|
||||
/**
|
||||
* Register default {@link ThreadPoolPlugin}.
|
||||
*
|
||||
* @author huangchengxing
|
||||
* @see TaskDecoratorPlugin
|
||||
* @see TaskTimeoutNotifyAlarmPlugin
|
||||
* @see TaskRejectCountRecordPlugin
|
||||
* @see TaskRejectNotifyAlarmPlugin
|
||||
* @see ThreadPoolExecutorShutdownPlugin
|
||||
*/
|
||||
@RequiredArgsConstructor
|
||||
public class DefaultThreadPoolPluginRegistrar
|
||||
implements ThreadPoolPluginRegistrar, ApplicationContextAware, BeanNameAware {
|
||||
|
||||
public static final String REGISTRAR_NAME = "DefaultThreadPoolPluginRegistrar";
|
||||
|
||||
/**
|
||||
* aliasRegistry
|
||||
*/
|
||||
private AliasRegistry aliasRegistry;
|
||||
|
||||
/**
|
||||
* execute time out
|
||||
*/
|
||||
private final long executeTimeOut;
|
||||
|
||||
/**
|
||||
* await termination millis
|
||||
*/
|
||||
private final long awaitTerminationMillis;
|
||||
|
||||
/**
|
||||
* wait for tasks to complete on shutdown
|
||||
*/
|
||||
private final boolean waitForTasksToCompleteOnShutdown;
|
||||
|
||||
/**
|
||||
* Get id.
|
||||
*
|
||||
* @return id
|
||||
*/
|
||||
@Override
|
||||
public String getId() {
|
||||
return REGISTRAR_NAME;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create and register plugin for the specified thread-pool instance
|
||||
*
|
||||
* @param registry thread pool plugin registry
|
||||
* @param executor executor
|
||||
*/
|
||||
@Override
|
||||
public void doRegister(ThreadPoolPluginRegistry registry, ExtensibleThreadPoolExecutor executor) {
|
||||
// callback when task execute
|
||||
registry.register(new TaskDecoratorPlugin());
|
||||
registry.register(new TaskTimeoutNotifyAlarmPlugin(executeTimeOut, executor));
|
||||
// callback when task rejected
|
||||
registry.register(new TaskRejectCountRecordPlugin());
|
||||
registry.register(new TaskRejectNotifyAlarmPlugin());
|
||||
// callback when pool shutdown
|
||||
registry.register(new ThreadPoolExecutorShutdownPlugin(awaitTerminationMillis, waitForTasksToCompleteOnShutdown));
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the name of the bean in the bean factory that created this bean.
|
||||
* <p>Invoked after population of normal bean properties but before an
|
||||
* init callback such as {@link InitializingBean#afterPropertiesSet()}
|
||||
* or a custom init-method.
|
||||
*
|
||||
* @param name the name of the bean in the factory.
|
||||
* Note that this name is the actual bean name used in the factory, which may
|
||||
* differ from the originally specified name: in particular for inner bean
|
||||
* names, the actual bean name might have been made unique through appending
|
||||
* "#..." suffixes. Use the {@link BeanFactoryUtils#originalBeanName(String)}
|
||||
* method to extract the original bean name (without suffix), if desired.
|
||||
*/
|
||||
@Override
|
||||
public void setBeanName(String name) {
|
||||
if (Objects.nonNull(aliasRegistry)) {
|
||||
aliasRegistry.registerAlias(name, getId());
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
|
||||
this.aliasRegistry = applicationContext.getBean(AliasRegistry.class);
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,187 @@
|
||||
/*
|
||||
* 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 cn.hippo4j.core.plugin;
|
||||
|
||||
import cn.hippo4j.common.toolkit.Assert;
|
||||
import lombok.NonNull;
|
||||
|
||||
import java.util.*;
|
||||
|
||||
/**
|
||||
* The default implementation of {@link ThreadPoolPluginRegistry}.
|
||||
*
|
||||
* @author huangchengxing
|
||||
*/
|
||||
public class DefaultThreadPoolPluginRegistry implements ThreadPoolPluginRegistry {
|
||||
|
||||
/**
|
||||
* Registered {@link ThreadPoolPlugin}.
|
||||
*/
|
||||
private final Map<String, ThreadPoolPlugin> registeredPlugins = new HashMap<>(16);
|
||||
|
||||
/**
|
||||
* Registered {@link TaskAwarePlugin}.
|
||||
*/
|
||||
private final List<TaskAwarePlugin> taskAwarePluginList = new ArrayList<>();
|
||||
|
||||
/**
|
||||
* Registered {@link ExecuteAwarePlugin}.
|
||||
*/
|
||||
private final List<ExecuteAwarePlugin> executeAwarePluginList = new ArrayList<>();
|
||||
|
||||
/**
|
||||
* Registered {@link RejectedAwarePlugin}.
|
||||
*/
|
||||
private final List<RejectedAwarePlugin> rejectedAwarePluginList = new ArrayList<>();
|
||||
|
||||
/**
|
||||
* Registered {@link ShutdownAwarePlugin}.
|
||||
*/
|
||||
private final List<ShutdownAwarePlugin> shutdownAwarePluginList = new ArrayList<>();
|
||||
|
||||
/**
|
||||
* Clear all.
|
||||
*/
|
||||
@Override
|
||||
public synchronized void clear() {
|
||||
registeredPlugins.clear();
|
||||
taskAwarePluginList.clear();
|
||||
executeAwarePluginList.clear();
|
||||
rejectedAwarePluginList.clear();
|
||||
shutdownAwarePluginList.clear();
|
||||
}
|
||||
|
||||
/**
|
||||
* Register a {@link ThreadPoolPlugin}
|
||||
*
|
||||
* @param aware aware
|
||||
* @throws IllegalArgumentException thrown when a plugin with the same {@link ThreadPoolPlugin#getId()} already exists in the registry
|
||||
* @see ThreadPoolPlugin#getId()
|
||||
*/
|
||||
@Override
|
||||
public synchronized void register(@NonNull ThreadPoolPlugin aware) {
|
||||
String id = aware.getId();
|
||||
Assert.isTrue(!isRegistered(id), "The plug-in with id [" + id + "] has been registered");
|
||||
|
||||
// register aware
|
||||
registeredPlugins.put(id, aware);
|
||||
// quick index
|
||||
if (aware instanceof TaskAwarePlugin) {
|
||||
taskAwarePluginList.add((TaskAwarePlugin) aware);
|
||||
}
|
||||
if (aware instanceof ExecuteAwarePlugin) {
|
||||
executeAwarePluginList.add((ExecuteAwarePlugin) aware);
|
||||
}
|
||||
if (aware instanceof RejectedAwarePlugin) {
|
||||
rejectedAwarePluginList.add((RejectedAwarePlugin) aware);
|
||||
}
|
||||
if (aware instanceof ShutdownAwarePlugin) {
|
||||
shutdownAwarePluginList.add((ShutdownAwarePlugin) aware);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Unregister {@link ThreadPoolPlugin}
|
||||
*
|
||||
* @param id name
|
||||
*/
|
||||
@Override
|
||||
public synchronized void unregister(String id) {
|
||||
Optional.ofNullable(id)
|
||||
.map(registeredPlugins::remove)
|
||||
.ifPresent(old -> {
|
||||
if (old instanceof TaskAwarePlugin) {
|
||||
taskAwarePluginList.remove(old);
|
||||
}
|
||||
if (old instanceof ExecuteAwarePlugin) {
|
||||
executeAwarePluginList.remove(old);
|
||||
}
|
||||
if (old instanceof RejectedAwarePlugin) {
|
||||
rejectedAwarePluginList.remove(old);
|
||||
}
|
||||
if (old instanceof ShutdownAwarePlugin) {
|
||||
shutdownAwarePluginList.remove(old);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Whether the {@link ThreadPoolPlugin} has been registered.
|
||||
*
|
||||
* @param id name
|
||||
* @return ture if target has been registered, false otherwise
|
||||
*/
|
||||
@Override
|
||||
public boolean isRegistered(String id) {
|
||||
return registeredPlugins.containsKey(id);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get {@link ThreadPoolPlugin}
|
||||
*
|
||||
* @param id target name
|
||||
* @param <A> target aware type
|
||||
* @return {@link ThreadPoolPlugin}, null if unregister
|
||||
*/
|
||||
@Override
|
||||
@SuppressWarnings("unchecked")
|
||||
public <A extends ThreadPoolPlugin> A getAware(String id) {
|
||||
return (A) registeredPlugins.get(id);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get execute aware list.
|
||||
*
|
||||
* @return {@link ExecuteAwarePlugin}
|
||||
*/
|
||||
@Override
|
||||
public Collection<ExecuteAwarePlugin> getExecuteAwareList() {
|
||||
return executeAwarePluginList;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get rejected aware list.
|
||||
*
|
||||
* @return {@link RejectedAwarePlugin}
|
||||
*/
|
||||
@Override
|
||||
public Collection<RejectedAwarePlugin> getRejectedAwareList() {
|
||||
return rejectedAwarePluginList;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get shutdown aware list.
|
||||
*
|
||||
* @return {@link ShutdownAwarePlugin}
|
||||
*/
|
||||
@Override
|
||||
public Collection<ShutdownAwarePlugin> getShutdownAwareList() {
|
||||
return shutdownAwarePluginList;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get shutdown aware list.
|
||||
*
|
||||
* @return {@link ShutdownAwarePlugin}
|
||||
*/
|
||||
@Override
|
||||
public Collection<TaskAwarePlugin> getTaskAwareList() {
|
||||
return taskAwarePluginList;
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,61 @@
|
||||
/*
|
||||
* 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 cn.hippo4j.core.plugin;
|
||||
|
||||
import cn.hippo4j.core.executor.ExtensibleThreadPoolExecutor;
|
||||
|
||||
/**
|
||||
* Callback during task execution.
|
||||
*
|
||||
* @author huangchengxing
|
||||
*/
|
||||
public interface ExecuteAwarePlugin extends ThreadPoolPlugin {
|
||||
|
||||
/**
|
||||
* Callback before task execution.
|
||||
*
|
||||
* @param thread thread of executing task
|
||||
* @param runnable task
|
||||
* @see ExtensibleThreadPoolExecutor#beforeExecute
|
||||
*/
|
||||
default void beforeExecute(Thread thread, Runnable runnable) {
|
||||
}
|
||||
|
||||
/**
|
||||
* Callback when task is executed.
|
||||
*
|
||||
* @param runnable runnable
|
||||
* @return tasks to be execute
|
||||
* @see ExtensibleThreadPoolExecutor#execute
|
||||
*/
|
||||
default Runnable execute(Runnable runnable) {
|
||||
return runnable;
|
||||
}
|
||||
|
||||
/**
|
||||
* Callback after task execution.
|
||||
*
|
||||
* @param runnable runnable
|
||||
* @param throwable exception thrown during execution
|
||||
* @see ExtensibleThreadPoolExecutor#afterExecute
|
||||
*/
|
||||
default void afterExecute(Runnable runnable, Throwable throwable) {
|
||||
// do nothing
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,39 @@
|
||||
/*
|
||||
* 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 cn.hippo4j.core.plugin;
|
||||
|
||||
import java.util.concurrent.ThreadPoolExecutor;
|
||||
|
||||
/**
|
||||
* Callback when task is rejected.
|
||||
*
|
||||
* @author huangchengxing
|
||||
*/
|
||||
public interface RejectedAwarePlugin extends ThreadPoolPlugin {
|
||||
|
||||
/**
|
||||
* Callback before task is rejected.
|
||||
*
|
||||
* @param runnable task
|
||||
* @param executor executor
|
||||
*/
|
||||
default void beforeRejectedExecution(Runnable runnable, ThreadPoolExecutor executor) {
|
||||
// do nothing
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,65 @@
|
||||
/*
|
||||
* 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 cn.hippo4j.core.plugin;
|
||||
|
||||
import cn.hippo4j.core.executor.ExtensibleThreadPoolExecutor;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.concurrent.ThreadPoolExecutor;
|
||||
|
||||
/**
|
||||
* Callback before thread-pool shutdown.
|
||||
*
|
||||
* @author huangchengxing
|
||||
*/
|
||||
public interface ShutdownAwarePlugin extends ThreadPoolPlugin {
|
||||
|
||||
/**
|
||||
* Callback before pool shutdown.
|
||||
*
|
||||
* @param executor executor
|
||||
* @see ThreadPoolExecutor#shutdown()
|
||||
* @see ThreadPoolExecutor#shutdownNow()
|
||||
*/
|
||||
default void beforeShutdown(ThreadPoolExecutor executor) {
|
||||
// do nothing
|
||||
}
|
||||
|
||||
/**
|
||||
* Callback after pool shutdown.
|
||||
*
|
||||
* @param executor executor
|
||||
* @param remainingTasks remainingTasks, or empty if no tasks left or {@link ThreadPoolExecutor#shutdown()} called
|
||||
* @see ThreadPoolExecutor#shutdown()
|
||||
* @see ThreadPoolExecutor#shutdownNow()
|
||||
*/
|
||||
default void afterShutdown(ThreadPoolExecutor executor, List<Runnable> remainingTasks) {
|
||||
// do nothing
|
||||
}
|
||||
|
||||
/**
|
||||
* Callback after pool terminated.
|
||||
*
|
||||
* @param executor executor
|
||||
* @see ThreadPoolExecutor#terminated()
|
||||
*/
|
||||
default void afterTerminated(ExtensibleThreadPoolExecutor executor) {
|
||||
// do nothing
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,54 @@
|
||||
/*
|
||||
* 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 cn.hippo4j.core.plugin;
|
||||
|
||||
import java.util.concurrent.Callable;
|
||||
import java.util.concurrent.ThreadPoolExecutor;
|
||||
|
||||
/**
|
||||
* Callback during task submit in thread-pool.
|
||||
*
|
||||
* @author huangchengxing
|
||||
*/
|
||||
public interface TaskAwarePlugin extends ThreadPoolPlugin {
|
||||
|
||||
/**
|
||||
* Callback during the {@link java.util.concurrent.RunnableFuture} task create in thread-pool.
|
||||
*
|
||||
* @param executor executor
|
||||
* @param runnable original task
|
||||
* @return Tasks that really need to be performed
|
||||
* @see ThreadPoolExecutor#newTaskFor(Runnable, Object)
|
||||
*/
|
||||
default <V> Runnable beforeTaskCreate(ThreadPoolExecutor executor, Runnable runnable, V value) {
|
||||
return runnable;
|
||||
}
|
||||
|
||||
/**
|
||||
* Callback during the {@link java.util.concurrent.RunnableFuture} task create in thread-pool.
|
||||
*
|
||||
* @param executor executor
|
||||
* @param future original task
|
||||
* @return Tasks that really need to be performed
|
||||
* @see ThreadPoolExecutor#newTaskFor(Callable)
|
||||
*/
|
||||
default <V> Callable<V> beforeTaskCreate(ThreadPoolExecutor executor, Callable<V> future) {
|
||||
return future;
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,42 @@
|
||||
/*
|
||||
* 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 cn.hippo4j.core.plugin;
|
||||
|
||||
import cn.hippo4j.core.executor.ExtensibleThreadPoolExecutor;
|
||||
|
||||
/**
|
||||
* Thread pool action aware.
|
||||
*
|
||||
* @author huangchengxing
|
||||
* @see ExtensibleThreadPoolExecutor
|
||||
* @see ThreadPoolPluginRegistry
|
||||
* @see TaskAwarePlugin
|
||||
* @see ExecuteAwarePlugin
|
||||
* @see ShutdownAwarePlugin
|
||||
* @see RejectedAwarePlugin
|
||||
*/
|
||||
public interface ThreadPoolPlugin {
|
||||
|
||||
/**
|
||||
* Get id.
|
||||
*
|
||||
* @return id
|
||||
*/
|
||||
String getId();
|
||||
|
||||
}
|
||||
@ -0,0 +1,27 @@
|
||||
package cn.hippo4j.core.plugin;
|
||||
|
||||
import cn.hippo4j.core.executor.ExtensibleThreadPoolExecutor;
|
||||
|
||||
/**
|
||||
* Factory of {@link ThreadPoolPlugin}.
|
||||
*
|
||||
* @author huangchengxing
|
||||
*/
|
||||
public interface ThreadPoolPluginRegistrar {
|
||||
|
||||
/**
|
||||
* Get id.
|
||||
*
|
||||
* @return id
|
||||
*/
|
||||
String getId();
|
||||
|
||||
/**
|
||||
* Create and register plugin for the specified thread-pool instance
|
||||
*
|
||||
* @param registry thread pool plugin registry
|
||||
* @param executor executor
|
||||
*/
|
||||
void doRegister(ThreadPoolPluginRegistry registry, ExtensibleThreadPoolExecutor executor);
|
||||
|
||||
}
|
||||
@ -0,0 +1,133 @@
|
||||
/*
|
||||
* 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 cn.hippo4j.core.plugin;
|
||||
|
||||
import java.util.Collection;
|
||||
import java.util.Optional;
|
||||
import java.util.function.Consumer;
|
||||
import java.util.function.Function;
|
||||
|
||||
/**
|
||||
* Registry of {@link ThreadPoolPlugin}
|
||||
*
|
||||
* @author huangchengxing
|
||||
*/
|
||||
public interface ThreadPoolPluginRegistry {
|
||||
|
||||
/**
|
||||
* Clear all.
|
||||
*/
|
||||
void clear();
|
||||
|
||||
/**
|
||||
* Register a {@link ThreadPoolPlugin}
|
||||
*
|
||||
* @param aware aware
|
||||
*/
|
||||
void register(ThreadPoolPlugin aware);
|
||||
|
||||
/**
|
||||
* Whether the {@link ThreadPoolPlugin} has been registered.
|
||||
*
|
||||
* @param name name
|
||||
* @return ture if target has been registered, false otherwise
|
||||
*/
|
||||
boolean isRegistered(String name);
|
||||
|
||||
/**
|
||||
* Unregister {@link ThreadPoolPlugin}
|
||||
*
|
||||
* @param name name
|
||||
*/
|
||||
void unregister(String name);
|
||||
|
||||
/**
|
||||
* Get {@link ThreadPoolPlugin}
|
||||
*
|
||||
* @param name target name
|
||||
* @param <A> target aware type
|
||||
* @return {@link ThreadPoolPlugin}, null if unregister
|
||||
* @throws ClassCastException thrown when the object obtained by name cannot be converted to target type
|
||||
*/
|
||||
<A extends ThreadPoolPlugin> A getAware(String name);
|
||||
|
||||
/**
|
||||
* Get execute aware list.
|
||||
*
|
||||
* @return {@link ExecuteAwarePlugin}
|
||||
*/
|
||||
Collection<ExecuteAwarePlugin> getExecuteAwareList();
|
||||
|
||||
/**
|
||||
* Get rejected aware list.
|
||||
*
|
||||
* @return {@link RejectedAwarePlugin}
|
||||
*/
|
||||
Collection<RejectedAwarePlugin> getRejectedAwareList();
|
||||
|
||||
/**
|
||||
* Get shutdown aware list.
|
||||
*
|
||||
* @return {@link ShutdownAwarePlugin}
|
||||
*/
|
||||
Collection<ShutdownAwarePlugin> getShutdownAwareList();
|
||||
|
||||
/**
|
||||
* Get shutdown aware list.
|
||||
*
|
||||
* @return {@link ShutdownAwarePlugin}
|
||||
*/
|
||||
Collection<TaskAwarePlugin> getTaskAwareList();
|
||||
|
||||
/**
|
||||
* Try to get target Aware and apply operation, do nothing if is not present.
|
||||
*
|
||||
* @param name aware name
|
||||
* @param targetType target type
|
||||
* @param consumer operation for target aware
|
||||
* @param <A> aware type
|
||||
* @return this instance
|
||||
* @throws ClassCastException thrown when the object obtained by name cannot be converted to target type
|
||||
*/
|
||||
default <A extends ThreadPoolPlugin> ThreadPoolPluginRegistry getAndThen(
|
||||
String name, Class<A> targetType, Consumer<A> consumer) {
|
||||
Optional.ofNullable(getAware(name))
|
||||
.map(targetType::cast)
|
||||
.ifPresent(consumer);
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Try to get target Aware and return value of apply function, return default value if is not present.
|
||||
*
|
||||
* @param name aware name
|
||||
* @param targetType target type
|
||||
* @param function operation for target aware
|
||||
* @param defaultValue default value
|
||||
* @param <A> aware type
|
||||
* @return value of apply function, default value if aware is not present
|
||||
* @throws ClassCastException thrown when the object obtained by name cannot be converted to target type
|
||||
*/
|
||||
default <A extends ThreadPoolPlugin, R> R getAndThen(String name, Class<A> targetType, Function<A, R> function, R defaultValue) {
|
||||
return Optional.ofNullable(getAware(name))
|
||||
.map(targetType::cast)
|
||||
.map(function)
|
||||
.orElse(defaultValue);
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,112 @@
|
||||
package cn.hippo4j.core.plugin;
|
||||
|
||||
import org.checkerframework.checker.nullness.qual.NonNull;
|
||||
|
||||
import java.util.Collection;
|
||||
|
||||
/**
|
||||
* Thread pool action aware registry delegate.
|
||||
*
|
||||
* @author huangchengxing
|
||||
*/
|
||||
public interface ThreadPoolPluginRegistryDelegate extends ThreadPoolPluginRegistry {
|
||||
|
||||
/**
|
||||
* Get thread pool action aware registry.
|
||||
*
|
||||
* @return {@link ThreadPoolPluginRegistry}
|
||||
*/
|
||||
@NonNull
|
||||
ThreadPoolPluginRegistry getThreadPoolPluginRegistry();
|
||||
|
||||
/**
|
||||
* Clear all.
|
||||
*/
|
||||
@Override
|
||||
default void clear() {
|
||||
getThreadPoolPluginRegistry().clear();
|
||||
}
|
||||
|
||||
/**
|
||||
* Register a {@link ThreadPoolPlugin}
|
||||
*
|
||||
* @param aware aware
|
||||
*/
|
||||
@Override
|
||||
default void register(ThreadPoolPlugin aware) {
|
||||
getThreadPoolPluginRegistry().register(aware);
|
||||
}
|
||||
|
||||
/**
|
||||
* Whether the {@link ThreadPoolPlugin} has been registered.
|
||||
*
|
||||
* @param name name
|
||||
* @return ture if target has been registered, false otherwise
|
||||
*/
|
||||
@Override
|
||||
default boolean isRegistered(String name) {
|
||||
return getThreadPoolPluginRegistry().isRegistered(name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Unregister {@link ThreadPoolPlugin}
|
||||
*
|
||||
* @param name name
|
||||
*/
|
||||
@Override
|
||||
default void unregister(String name) {
|
||||
getThreadPoolPluginRegistry().unregister(name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get {@link ThreadPoolPlugin}
|
||||
*
|
||||
* @param name target name
|
||||
* @return {@link ThreadPoolPlugin}, null if unregister
|
||||
* @throws ClassCastException thrown when the object obtained by name cannot be converted to target type
|
||||
*/
|
||||
@Override
|
||||
default <A extends ThreadPoolPlugin> A getAware(String name) {
|
||||
return getThreadPoolPluginRegistry().getAware(name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get execute aware list.
|
||||
*
|
||||
* @return {@link ExecuteAwarePlugin}
|
||||
*/
|
||||
@Override
|
||||
default Collection<ExecuteAwarePlugin> getExecuteAwareList() {
|
||||
return getThreadPoolPluginRegistry().getExecuteAwareList();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get rejected aware list.
|
||||
*
|
||||
* @return {@link RejectedAwarePlugin}
|
||||
*/
|
||||
@Override
|
||||
default Collection<RejectedAwarePlugin> getRejectedAwareList() {
|
||||
return getThreadPoolPluginRegistry().getRejectedAwareList();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get shutdown aware list.
|
||||
*
|
||||
* @return {@link ShutdownAwarePlugin}
|
||||
*/
|
||||
@Override
|
||||
default Collection<ShutdownAwarePlugin> getShutdownAwareList() {
|
||||
return getThreadPoolPluginRegistry().getShutdownAwareList();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get shutdown aware list.
|
||||
*
|
||||
* @return {@link ShutdownAwarePlugin}
|
||||
*/
|
||||
@Override
|
||||
default Collection<TaskAwarePlugin> getTaskAwareList() {
|
||||
return getThreadPoolPluginRegistry().getTaskAwareList();
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,95 @@
|
||||
/*
|
||||
* 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 cn.hippo4j.core.plugin.impl;
|
||||
|
||||
import cn.hippo4j.core.executor.ExtensibleThreadPoolExecutor;
|
||||
import cn.hippo4j.core.plugin.ExecuteAwarePlugin;
|
||||
import lombok.Getter;
|
||||
import lombok.NonNull;
|
||||
import org.springframework.core.task.TaskDecorator;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Decorate tasks when they are submitted to thread-pool.
|
||||
*
|
||||
* @author huangchengxing
|
||||
*/
|
||||
public class TaskDecoratorPlugin implements ExecuteAwarePlugin {
|
||||
|
||||
public static final String PLUGIN_NAME = "task-decorator-plugin";
|
||||
|
||||
/**
|
||||
* Get id.
|
||||
*
|
||||
* @return id
|
||||
*/
|
||||
@Override
|
||||
public String getId() {
|
||||
return PLUGIN_NAME;
|
||||
}
|
||||
|
||||
/**
|
||||
* decorators
|
||||
*/
|
||||
@Getter
|
||||
private final List<TaskDecorator> decorators = new ArrayList<>();
|
||||
|
||||
/**
|
||||
* Callback when task is executed.
|
||||
*
|
||||
* @param runnable runnable
|
||||
* @return tasks to be execute
|
||||
* @see ExtensibleThreadPoolExecutor#execute
|
||||
*/
|
||||
@Override
|
||||
public Runnable execute(Runnable runnable) {
|
||||
for (TaskDecorator decorator : decorators) {
|
||||
runnable = decorator.decorate(runnable);
|
||||
}
|
||||
return runnable;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a decorator
|
||||
*
|
||||
* @param decorator decorator
|
||||
*/
|
||||
public void addDecorator(@NonNull TaskDecorator decorator) {
|
||||
decorators.remove(decorator);
|
||||
decorators.add(decorator);
|
||||
}
|
||||
|
||||
/**
|
||||
* Clear all decorators
|
||||
*
|
||||
*/
|
||||
public void clearDecorators() {
|
||||
decorators.clear();
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove decorators
|
||||
*
|
||||
*/
|
||||
public void removeDecorator(TaskDecorator decorator) {
|
||||
decorators.remove(decorator);
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,73 @@
|
||||
/*
|
||||
* 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 cn.hippo4j.core.plugin.impl;
|
||||
|
||||
import cn.hippo4j.core.plugin.RejectedAwarePlugin;
|
||||
import lombok.Getter;
|
||||
import lombok.Setter;
|
||||
|
||||
import java.util.concurrent.ThreadPoolExecutor;
|
||||
import java.util.concurrent.atomic.AtomicLong;
|
||||
|
||||
/**
|
||||
* Record the number of tasks rejected by the thread pool.
|
||||
*
|
||||
* @author huangchengxing
|
||||
*/
|
||||
public class TaskRejectCountRecordPlugin implements RejectedAwarePlugin {
|
||||
|
||||
public static final String PLUGIN_NAME = "task-reject-count-record-plugin";
|
||||
|
||||
/**
|
||||
* Get id.
|
||||
*
|
||||
* @return id
|
||||
*/
|
||||
@Override
|
||||
public String getId() {
|
||||
return PLUGIN_NAME;
|
||||
}
|
||||
|
||||
/**
|
||||
* rejection count
|
||||
*/
|
||||
@Setter
|
||||
@Getter
|
||||
private AtomicLong rejectCount = new AtomicLong(0);
|
||||
|
||||
/**
|
||||
* Record rejection count.
|
||||
*
|
||||
* @param r task
|
||||
* @param executor executor
|
||||
*/
|
||||
@Override
|
||||
public void beforeRejectedExecution(Runnable r, ThreadPoolExecutor executor) {
|
||||
rejectCount.incrementAndGet();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get reject count num
|
||||
*
|
||||
* @return reject count num
|
||||
*/
|
||||
public Long getRejectCountNum() {
|
||||
return rejectCount.get();
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,63 @@
|
||||
/*
|
||||
* 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 cn.hippo4j.core.plugin.impl;
|
||||
|
||||
import cn.hippo4j.common.config.ApplicationContextHolder;
|
||||
import cn.hippo4j.core.executor.ExtensibleThreadPoolExecutor;
|
||||
import cn.hippo4j.core.executor.ThreadPoolNotifyAlarmHandler;
|
||||
import cn.hippo4j.core.plugin.RejectedAwarePlugin;
|
||||
|
||||
import java.util.Optional;
|
||||
import java.util.concurrent.ThreadPoolExecutor;
|
||||
|
||||
/**
|
||||
* Send alert notification when a task is rejected.
|
||||
*
|
||||
* @author huangchengxing
|
||||
*/
|
||||
public class TaskRejectNotifyAlarmPlugin implements RejectedAwarePlugin {
|
||||
|
||||
public static final String PLUGIN_NAME = "task-reject-notify-alarm-plugin";
|
||||
|
||||
/**
|
||||
* Get id.
|
||||
*
|
||||
* @return id
|
||||
*/
|
||||
@Override
|
||||
public String getId() {
|
||||
return PLUGIN_NAME;
|
||||
}
|
||||
|
||||
/**
|
||||
* Callback before task is rejected.
|
||||
*
|
||||
* @param runnable task
|
||||
* @param executor executor
|
||||
*/
|
||||
@Override
|
||||
public void beforeRejectedExecution(Runnable runnable, ThreadPoolExecutor executor) {
|
||||
if (!(executor instanceof ExtensibleThreadPoolExecutor)) {
|
||||
return;
|
||||
}
|
||||
String threadPoolId = ((ExtensibleThreadPoolExecutor) executor).getThreadPoolId();
|
||||
Optional.ofNullable(ApplicationContextHolder.getInstance())
|
||||
.map(context -> context.getBean(ThreadPoolNotifyAlarmHandler.class))
|
||||
.ifPresent(handler -> handler.asyncSendRejectedAlarm(threadPoolId));
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,96 @@
|
||||
/*
|
||||
* 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 cn.hippo4j.core.plugin.impl;
|
||||
|
||||
import cn.hippo4j.common.toolkit.SyncTimeRecorder;
|
||||
import cn.hippo4j.core.executor.ExtensibleThreadPoolExecutor;
|
||||
import cn.hippo4j.core.plugin.ExecuteAwarePlugin;
|
||||
import cn.hippo4j.core.toolkit.SystemClock;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
|
||||
import java.util.Objects;
|
||||
|
||||
/**
|
||||
* Record task execution time indicator.
|
||||
*
|
||||
* @author huangchengxing
|
||||
* @see TaskTimeoutNotifyAlarmPlugin
|
||||
*/
|
||||
@RequiredArgsConstructor
|
||||
public class TaskTimeRecordAwareProcessorPlugin extends SyncTimeRecorder implements ExecuteAwarePlugin {
|
||||
|
||||
public static final String PLUGIN_NAME = "task-time-record-aware-processor";
|
||||
|
||||
/**
|
||||
* Get id.
|
||||
*
|
||||
* @return id
|
||||
*/
|
||||
@Override
|
||||
public String getId() {
|
||||
return PLUGIN_NAME;
|
||||
}
|
||||
|
||||
/**
|
||||
* start times of executed tasks
|
||||
*/
|
||||
private final ThreadLocal<Long> startTimes = new ThreadLocal<>();
|
||||
|
||||
/**
|
||||
* Record the time when the worker thread starts executing the task.
|
||||
*
|
||||
* @param thread thread of executing task
|
||||
* @param runnable task
|
||||
* @see ExtensibleThreadPoolExecutor#beforeExecute
|
||||
*/
|
||||
@Override
|
||||
public void beforeExecute(Thread thread, Runnable runnable) {
|
||||
startTimes.set(SystemClock.now());
|
||||
}
|
||||
|
||||
/**
|
||||
* Record the total time for the worker thread to complete the task, and update the time record.
|
||||
*
|
||||
* @param runnable runnable
|
||||
* @param throwable exception thrown during execution
|
||||
*/
|
||||
@Override
|
||||
public void afterExecute(Runnable runnable, Throwable throwable) {
|
||||
try {
|
||||
Long startTime = startTimes.get();
|
||||
if (Objects.isNull(startTime)) {
|
||||
return;
|
||||
}
|
||||
long executeTime = SystemClock.now() - startTime;
|
||||
refreshTime(executeTime);
|
||||
afterRefreshTime(executeTime);
|
||||
} finally {
|
||||
startTimes.remove();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The callback function provided to the subclass, which is called after {@link #refreshTime}
|
||||
*
|
||||
* @param executeTime executeTime
|
||||
*/
|
||||
protected void afterRefreshTime(long executeTime) {
|
||||
// do nothing
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,75 @@
|
||||
/*
|
||||
* 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 cn.hippo4j.core.plugin.impl;
|
||||
|
||||
import cn.hippo4j.common.config.ApplicationContextHolder;
|
||||
import cn.hippo4j.core.executor.ExtensibleThreadPoolExecutor;
|
||||
import cn.hippo4j.core.executor.ThreadPoolNotifyAlarmHandler;
|
||||
import lombok.AllArgsConstructor;
|
||||
import lombok.Getter;
|
||||
import lombok.Setter;
|
||||
|
||||
import java.util.Optional;
|
||||
|
||||
/**
|
||||
* Record task execution time indicator,
|
||||
* and send alarm notification when the execution time exceeds the threshold.
|
||||
*
|
||||
* @author huangchengxing
|
||||
*/
|
||||
@AllArgsConstructor
|
||||
public class TaskTimeoutNotifyAlarmPlugin extends TaskTimeRecordAwareProcessorPlugin {
|
||||
|
||||
public static final String PLUGIN_NAME = "task-timeout-notify-alarm-plugin";
|
||||
|
||||
/**
|
||||
* Get id.
|
||||
*
|
||||
* @return id
|
||||
*/
|
||||
@Override
|
||||
public String getId() {
|
||||
return PLUGIN_NAME;
|
||||
}
|
||||
|
||||
@Getter
|
||||
@Setter
|
||||
private Long executeTimeOut;
|
||||
|
||||
/**
|
||||
* thread-pool
|
||||
*/
|
||||
private final ExtensibleThreadPoolExecutor threadPoolExecutor;
|
||||
|
||||
/**
|
||||
* Check whether the task execution time exceeds {@link #executeTimeOut},
|
||||
* if it exceeds this time, send an alarm notification.
|
||||
*
|
||||
* @param executeTime executeTime in nanosecond
|
||||
*/
|
||||
@Override
|
||||
public void afterRefreshTime(long executeTime) {
|
||||
if (executeTime <= executeTimeOut) {
|
||||
return;
|
||||
}
|
||||
Optional.ofNullable(ApplicationContextHolder.getInstance())
|
||||
.map(context -> context.getBean(ThreadPoolNotifyAlarmHandler.class))
|
||||
.ifPresent(handler -> handler.asyncSendExecuteTimeOutAlarm(
|
||||
threadPoolExecutor.getThreadPoolId(), executeTime, executeTimeOut, threadPoolExecutor));
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,9 @@
|
||||
package cn.hippo4j.core.executor;
|
||||
|
||||
/**
|
||||
* test for {@link ExtensibleThreadPoolExecutor}
|
||||
*
|
||||
* @author huangchengxing
|
||||
*/
|
||||
public class ActionAwareThreadPoolExecutorTest {
|
||||
}
|
||||
@ -0,0 +1,9 @@
|
||||
package cn.hippo4j.core.executor;
|
||||
|
||||
/**
|
||||
* test for {@link DynamicThreadPoolExecutor}
|
||||
*
|
||||
* @author huangchengxing
|
||||
*/
|
||||
public class DynamicThreadPoolExecutorTest {
|
||||
}
|
||||
@ -0,0 +1,93 @@
|
||||
package cn.hippo4j.core.plugin;
|
||||
|
||||
import org.junit.Assert;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
|
||||
/**
|
||||
* test for {@link DefaultThreadPoolPluginRegistry}
|
||||
*
|
||||
* @author huangchengxing
|
||||
*/
|
||||
public class DefaultThreadPoolPluginRegistryTest {
|
||||
|
||||
private DefaultThreadPoolPluginRegistry registry;
|
||||
|
||||
@Before
|
||||
public void initRegistry() {
|
||||
registry = new DefaultThreadPoolPluginRegistry();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testRegister() {
|
||||
TaskAwarePlugin taskAwarePlugin = new TestTaskAwarePlugin();
|
||||
registry.register(taskAwarePlugin);
|
||||
Assert.assertTrue(registry.isRegistered(taskAwarePlugin));
|
||||
Assert.assertEquals(1, registry.getTaskAwareList().size());
|
||||
|
||||
ExecuteAwarePlugin executeAwarePlugin = new TestExecuteAwarePlugin();
|
||||
registry.register(executeAwarePlugin);
|
||||
Assert.assertTrue(registry.isRegistered(executeAwarePlugin));
|
||||
Assert.assertEquals(1, registry.getExecuteAwareList().size());
|
||||
|
||||
RejectedAwarePlugin rejectedAwarePlugin = new TestRejectedAwarePlugin();
|
||||
registry.register(rejectedAwarePlugin);
|
||||
Assert.assertTrue(registry.isRegistered(rejectedAwarePlugin));
|
||||
Assert.assertEquals(1, registry.getRejectedAwareList().size());
|
||||
|
||||
ShutdownAwarePlugin shutdownAwarePlugin = new TestShutdownAwarePlugin();
|
||||
registry.register(shutdownAwarePlugin);
|
||||
Assert.assertTrue(registry.isRegistered(shutdownAwarePlugin));
|
||||
Assert.assertEquals(1, registry.getShutdownAwareList().size());
|
||||
}
|
||||
|
||||
private final static class TestTaskAwarePlugin implements TaskAwarePlugin {
|
||||
/**
|
||||
* Get id.
|
||||
*
|
||||
* @return id
|
||||
*/
|
||||
@Override
|
||||
public String getId() {
|
||||
return "TestTaskAwarePlugin";
|
||||
}
|
||||
}
|
||||
|
||||
private final static class TestExecuteAwarePlugin implements ExecuteAwarePlugin {
|
||||
/**
|
||||
* Get id.
|
||||
*
|
||||
* @return id
|
||||
*/
|
||||
@Override
|
||||
public String getId() {
|
||||
return "TestExecuteAwarePlugin";
|
||||
}
|
||||
}
|
||||
|
||||
private final static class TestRejectedAwarePlugin implements RejectedAwarePlugin {
|
||||
/**
|
||||
* Get id.
|
||||
*
|
||||
* @return id
|
||||
*/
|
||||
@Override
|
||||
public String getId() {
|
||||
return "TestRejectedAwarePlugin";
|
||||
}
|
||||
}
|
||||
|
||||
private final static class TestShutdownAwarePlugin implements ShutdownAwarePlugin {
|
||||
/**
|
||||
* Get id.
|
||||
*
|
||||
* @return id
|
||||
*/
|
||||
@Override
|
||||
public String getId() {
|
||||
return "TestShutdownAwarePlugin";
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
@ -0,0 +1,9 @@
|
||||
package cn.hippo4j.core.plugin.impl;
|
||||
|
||||
/**
|
||||
* test for {@link TaskDecoratorPlugin}
|
||||
*
|
||||
* @author huangchengxing
|
||||
*/
|
||||
public class TaskDecoratorPluginTest {
|
||||
}
|
||||
@ -0,0 +1,9 @@
|
||||
package cn.hippo4j.core.plugin.impl;
|
||||
|
||||
/**
|
||||
* test for {@link TaskRejectCountRecordPlugin}
|
||||
*
|
||||
* @author huangchengxing
|
||||
*/
|
||||
public class TaskRejectCountRecordPluginTest {
|
||||
}
|
||||
@ -0,0 +1,9 @@
|
||||
package cn.hippo4j.core.plugin.impl;
|
||||
|
||||
/**
|
||||
* test for {@link TaskRejectNotifyAlarmPlugin}
|
||||
*
|
||||
* @author huangchengxing
|
||||
*/
|
||||
public class TaskRejectNotifyAlarmPluginTest {
|
||||
}
|
||||
@ -0,0 +1,9 @@
|
||||
package cn.hippo4j.core.plugin.impl;
|
||||
|
||||
/**
|
||||
* test for {@link TaskTimeRecordAwareProcessorPlugin}
|
||||
*
|
||||
* @author huangchengxing
|
||||
*/
|
||||
public class TaskTimeRecordPluginTest {
|
||||
}
|
||||
@ -0,0 +1,9 @@
|
||||
package cn.hippo4j.core.plugin.impl;
|
||||
|
||||
/**
|
||||
* test for {@link ThreadPoolExecutorShutdownPlugin}
|
||||
*
|
||||
* @author huangchengxing
|
||||
*/
|
||||
public class ThreadPoolExecutorShutdownPluginTest {
|
||||
}
|
||||
@ -0,0 +1,9 @@
|
||||
package cn.hippo4j.core.plugin.impl;
|
||||
|
||||
/**
|
||||
* test for {@link TaskTimeoutNotifyAlarmPlugin}
|
||||
*
|
||||
* @author huangchengxing
|
||||
*/
|
||||
public class TimeoutNotifyAlarmTaskTimeRecordPluginTest {
|
||||
}
|
||||
Loading…
Reference in new issue