scheduled优化

docs/scheduled.md

@@ -5,11 +5,11 @@
 |属性|默认值|说明|
 | --- | --- | --- |
 |name|未定义|名称, 可用于第三方实现的定时任务组件的key, 比如xxl-job的任务标识|
-|cron|未定义|cron表达式，也可以使用常量值: <br> &emsp;@yearly、@annually、@monthly、@weekly、<br> &emsp;@daily、@midnight、@hourly、@minutely <br> &emsp;@1m、@2m、@3m、@5m、@10m、@15m、@30m <br> &emsp;@1h、@2h、@3h、@6h <br> &emsp;${env.scheduling.cron}: 读取系统配置项|
+|cron|未定义|cron表达式，也可以使用常量值: <br> &emsp;@yearly、@annually、@monthly、@weekly、<br> &emsp;@daily、@midnight、@hourly、@minutely <br> &emsp;@1m、@2m、@3m、@5m、@10m、@15m、@30m <br> &emsp;@1h、@2h、@3h、@6h <br> &emsp;${env.scheduled.cron}: 读取系统配置项|
 |zone|未定义|时区，```cron```有值才有效, 例如: "Asia/Shanghai"|
-|fixedDelay|-1|延迟时间，负数为无效值，支持参数配置、乘法表达式和对象字段值 <br> 参数值支持方式:<br> &emsp;100: 设置数值 <br> &emsp;${env.scheduling.fixedDelay}: 读取系统配置项 <br> 值大于0且fixedRate小于0则使用 ScheduledThreadPoolExecutor.scheduleWithFixedDelay |
+|fixedDelay|-1|延迟时间，负数为无效值，支持参数配置、乘法表达式和对象字段值 <br> 参数值支持方式:<br> &emsp;100: 设置数值 <br> &emsp;${env.scheduled.fixedDelay}: 读取系统配置项 <br> 值大于0且fixedRate小于0则使用 ScheduledThreadPoolExecutor.scheduleWithFixedDelay |
-|fixedRate|-1|周期时间，负数为无效值，支持参数配置、乘法表达式和对象字段值 <br> 参数值支持方式:<br> &emsp;100: 设置数值 <br> &emsp;${env.scheduling.fixedRate}: 读取系统配置项 <br> 值大于0且fixedRate小于0则使用 ScheduledThreadPoolExecutor.scheduleAtFixedRate |
+|fixedRate|-1|周期时间，负数为无效值，支持参数配置、乘法表达式和对象字段值 <br> 参数值支持方式:<br> &emsp;100: 设置数值 <br> &emsp;${env.scheduled.fixedRate}: 读取系统配置项 <br> 值大于0且fixedRate小于0则使用 ScheduledThreadPoolExecutor.scheduleAtFixedRate |
-|initialDelay|-1|起始延迟时间，负数为无效值，支持参数配置、乘法表达式和对象字段值 <br> 参数值支持方式:<br> &emsp;100: 设置数值 <br> &emsp;${env.scheduling.initialDelay}: 读取系统配置项 <br> 值大于0且fixedRate和fixedDelay小于0则使用 ScheduledThreadPoolExecutor.schedule |
+|initialDelay|-1|起始延迟时间，负数为无效值，支持参数配置、乘法表达式和对象字段值 <br> 参数值支持方式:<br> &emsp;100: 设置数值 <br> &emsp;${env.scheduled.initialDelay}: 读取系统配置项 <br> 值大于0且fixedRate和fixedDelay小于0则使用 ScheduledThreadPoolExecutor.schedule |
 |timeUnit|```TimeUnit.SECONDS```|时间单位TimeUnit|
 |comment|未定义|备注描述|
 |mode|```LoadMode.LOCAL```|作用于Service模式，默认值为：LOCAL，<br> LOCAL: 表示远程模式的Service对象中的定时任务不起作用|
@@ -31,9 +31,9 @@
     }
 ```
 
-&emsp;&emsp;<b>环境配置</b>, 定时间隔时间由环境变量```env.schedule.fixedRate```配置，没配置采用默认值60秒)
+&emsp;&emsp;<b>环境配置</b>, 定时间隔时间由环境变量```env.scheduled.fixedRate```配置，没配置采用默认值60秒)
 ```java
-    @Scheduled(fixedRate = "${env.schedule.fixedRate:60}")
+    @Scheduled(fixedRate = "${env.scheduled.fixedRate:60}")
     public String task2() {
         System.out.println(Times.nowMillis() + "执行一次");
         return "";
@@ -47,7 +47,7 @@
         全局Serivce的定时任务设置，没配置该节点将自动创建一个。
         enabled： 是否开启缓存功能。默认: true
     -->
-    <schedule enabled="true"/>
+    <scheduled enabled="true"/>
 ```
 
 

src/main/java/META-INF/application-template.xml

@@ -40,7 +40,7 @@ serviceid1_name1  serviceid1_name2   serviceid2_name1  serviceid2_name2
         全局Serivce的定时任务设置，没配置该节点将自动创建一个。
         enabled： 是否开启缓存功能。默认: true
     -->
-    <schedule enabled="true"/>
+    <scheduled enabled="true"/>
 
     <!--
     【节点全局唯一】 @since 2.8.0

src/main/java/module-info.java

@@ -34,8 +34,8 @@ module org.redkale {
     exports org.redkale.net.sncp;
     exports org.redkale.persistence;
     exports org.redkale.props.spi;
-    exports org.redkale.schedule;
+    exports org.redkale.scheduled;
-    exports org.redkale.schedule.spi;
+    exports org.redkale.scheduled.spi;
     exports org.redkale.service;
     exports org.redkale.source;
     exports org.redkale.source.spi;
@@ -47,7 +47,7 @@ module org.redkale {
     uses org.redkale.cluster.spi.ClusterAgentProvider;
     uses org.redkale.convert.spi.ConvertProvider;
     uses org.redkale.mq.spi.MessageAgentProvider;
-    uses org.redkale.schedule.spi.ScheduleManagerProvider;
+    uses org.redkale.scheduled.spi.ScheduledManagerProvider;
     uses org.redkale.source.spi.CacheSourceProvider;
     uses org.redkale.source.spi.DataSourceProvider;
     uses org.redkale.source.spi.DataNativeSqlParserProvider;

src/main/java/org/redkale/boot/Application.java

@@ -42,7 +42,7 @@ import org.redkale.net.*;
 import org.redkale.net.http.*;
 import org.redkale.net.sncp.*;
 import org.redkale.props.spi.PropertiesModule;
-import org.redkale.schedule.spi.ScheduleModuleEngine;
+import org.redkale.scheduled.spi.ScheduledModuleEngine;
 import org.redkale.service.Service;
 import org.redkale.source.*;
 import org.redkale.source.spi.SourceModuleEngine;
@@ -311,7 +311,7 @@ public final class Application {
         moduleEngines.add(this.sourceModule); // 放第一，很多module依赖于source
         moduleEngines.add(new MessageModuleEngine(this));
         moduleEngines.add(new ClusterModuleEngine(this));
-        moduleEngines.add(new ScheduleModuleEngine(this));
+        moduleEngines.add(new ScheduledModuleEngine(this));
         moduleEngines.add(new CachedModuleEngine(this));
         moduleEngines.add(new LockedModuleEngine(this));
 

src/main/java/org/redkale/net/AsyncNioConnection.java

@@ -39,6 +39,7 @@ abstract class AsyncNioConnection extends AsyncConnection {
     protected final AsyncNioCompletionHandler<ByteBuffer> readTimeoutCompletionHandler =
             new AsyncNioCompletionHandler<>(true, this);
 
+    //值大于0才有效
     protected int readTimeoutSeconds;
 
     protected ByteBuffer readByteBuffer;
@@ -51,6 +52,7 @@ abstract class AsyncNioConnection extends AsyncConnection {
     protected final AsyncNioCompletionHandler<Object> writeTimeoutCompletionHandler =
             new AsyncNioCompletionHandler<>(false, this);
 
+    //值大于0才有效
     protected int writeTimeoutSeconds;
 
     protected byte[] writeByteTuple1Array;

src/main/java/org/redkale/net/client/Client.java

@@ -333,6 +333,15 @@ public abstract class Client<C extends ClientConnection<R, P>, R extends ClientR
         return connect(addr, WorkThread.currentWorkThread(), false);
     }
 
+    public final CompletableFuture<C> newConnection(int readTimeout, int writeTimeout) {
+        return connect(getAddress(null), WorkThread.currentWorkThread(), false, readTimeout, writeTimeout);
+    }
+
+    // 指定地址获取连接
+    public final CompletableFuture<C> newConnection(SocketAddress addr, int readTimeout, int writeTimeout) {
+        return connect(addr, WorkThread.currentWorkThread(), false, readTimeout, writeTimeout);
+    }
+
     public final CompletableFuture<C> connect() {
         return connect(getAddress(null), WorkThread.currentWorkThread(), true);
     }
@@ -354,6 +363,16 @@ public abstract class Client<C extends ClientConnection<R, P>, R extends ClientR
     // 指定地址获取连接
     private CompletableFuture<C> connect(
             @Nonnull final SocketAddress addr, @Nullable final WorkThread workThread, final boolean pool) {
+        return connect(addr, workThread, pool, readTimeoutSeconds, writeTimeoutSeconds);
+    }
+
+    // 指定地址获取连接
+    private CompletableFuture<C> connect(
+            @Nonnull final SocketAddress addr,
+            @Nullable final WorkThread workThread,
+            final boolean pool,
+            final int readTimeout,
+            final int writeTimeout) {
         if (addr == null) {
             return CompletableFuture.failedFuture(new NullPointerException("address is empty"));
         }
@@ -366,7 +385,7 @@ public abstract class Client<C extends ClientConnection<R, P>, R extends ClientR
         final Queue<CompletableFuture<C>> waitQueue = entry.connAcquireWaitings;
         if (!pool || entry.connOpenState.compareAndSet(false, true)) {
             CompletableFuture<C> future = group.createClient(
-                            tcp, addr, connectTimeoutSeconds, readTimeoutSeconds, writeTimeoutSeconds)
+                            tcp, addr, connectTimeoutSeconds, readTimeout, writeTimeout)
                     .thenApply(c ->
                             (C) createClientConnection(c).setConnEntry(entry).setMaxPipelines(maxPipelines));
             R virtualReq = createVirtualRequestAfterConnect();

src/main/java/org/redkale/net/sncp/Sncp.java

@@ -24,7 +24,7 @@ import org.redkale.inject.ResourceFactory;
 import org.redkale.mq.spi.MessageAgent;
 import org.redkale.net.http.WebSocketNode;
 import org.redkale.net.sncp.SncpRemoteInfo.SncpRemoteAction;
-import org.redkale.schedule.Scheduled;
+import org.redkale.scheduled.Scheduled;
 import org.redkale.service.*;
 import org.redkale.util.AnyValue;
 import org.redkale.util.RedkaleClassLoader;

src/main/java/org/redkale/props/spi/PropertiesModule.java

@@ -175,9 +175,9 @@ public class PropertiesModule extends BootModule {
             if (key.startsWith("redkale.executor.") // 节点全局唯一
                     || key.startsWith("redkale.transport.") // 节点全局唯一
                     || key.startsWith("redkale.cluster.") // 节点全局唯一
-                    || key.startsWith("redkale.cache.") // 节点全局唯一
+                    || key.startsWith("redkale.cached.") // 节点全局唯一
-                    || key.startsWith("redkale.schedule.") // 节点全局唯一
+                    || key.startsWith("redkale.scheduled.") // 节点全局唯一
-                    || key.startsWith("redkale.lock.") // 节点全局唯一
+                    || key.startsWith("redkale.locked.") // 节点全局唯一
                     || key.startsWith("redkale.mq.")
                     || key.startsWith("redkale.mq[")
                     || key.startsWith("redkale.group.")

src/main/java/org/redkale/schedule/spi/ScheduleManagerProvider.java

@@ -1,17 +0,0 @@
-/*
- *
- */
-package org.redkale.schedule.spi;
-
-import org.redkale.schedule.ScheduleManager;
-import org.redkale.util.InstanceProvider;
-
-/**
- * 自定义的ScheduleManager加载器, 如果标记@Priority加载器的优先级需要大于1000， 1000以下预留给官方加载器
- *
- * <p>详情见: https://redkale.org
- *
- * @author zhangjx
- * @since 2.8.0
- */
-public interface ScheduleManagerProvider extends InstanceProvider<ScheduleManager> {}

src/main/java/org/redkale/scheduled/Scheduled.java

@@ -1,7 +1,7 @@
 /*
  *
  */
-package org.redkale.schedule;
+package org.redkale.scheduled;
 
 import java.lang.annotation.*;
 import java.util.concurrent.TimeUnit;

src/main/java/org/redkale/scheduled/ScheduledEvent.java

@@ -1,7 +1,7 @@
 /*
  *
  */
-package org.redkale.schedule;
+package org.redkale.scheduled;
 
 import java.lang.reflect.Type;
 import java.util.HashMap;
@@ -17,15 +17,15 @@ import org.redkale.util.Utility;
  * @author zhangjx
  * @since 2.8.0
  */
-public final class ScheduleEvent {
+public final class ScheduledEvent {
 
     private final Map<String, Object> map;
 
-    public ScheduleEvent() {
+    public ScheduledEvent() {
         this.map = new HashMap<>();
     }
 
-    public ScheduleEvent(Map<String, Object> map) {
+    public ScheduledEvent(Map<String, Object> map) {
         this.map = map;
     }
 
@@ -67,7 +67,7 @@ public final class ScheduleEvent {
         return Utility.convertValue(long.class, val);
     }
 
-    public ScheduleEvent clear() {
+    public ScheduledEvent clear() {
         map.clear();
         return this;
     }

src/main/java/org/redkale/scheduled/ScheduledManager.java

@@ -1,7 +1,7 @@
 /*
  *
  */
-package org.redkale.schedule;
+package org.redkale.scheduled;
 
 /**
  * 定时管理器
@@ -11,7 +11,7 @@ package org.redkale.schedule;
  * @author zhangjx
  * @since 2.8.0
  */
-public interface ScheduleManager {
+public interface ScheduledManager {
 
     /**
      * 开启宿主对象中所有的定时任务方法. 存在定时任务方法返回true，否则返回false
@@ -23,7 +23,7 @@ public interface ScheduleManager {
     /**
      * 开启所有宿主对象中指定的任务名
      *
-     * @see org.redkale.schedule.Scheduled#name()
+     * @see org.redkale.scheduled.Scheduled#name()
      * @param scheduleName 定时任务名称
      * @return 返回任务数量
      */
@@ -39,7 +39,7 @@ public interface ScheduleManager {
     /**
      * 关闭所有宿主对象中指定的任务名
      *
-     * @see org.redkale.schedule.Scheduled#name()
+     * @see org.redkale.scheduled.Scheduled#name()
      * @param scheduleName 定时任务名称
      * @return 返回任务数量
      */

src/main/java/org/redkale/scheduled/spi/CronExpression.java

@@ -1,7 +1,7 @@
 /*
  *
  */
-package org.redkale.schedule.spi;
+package org.redkale.scheduled.spi;
 
 import java.time.DateTimeException;
 import java.time.temporal.ChronoField;

src/main/java/org/redkale/scheduled/spi/ScheduleManagerService.java

@@ -1,7 +1,7 @@
 /*
  *
  */
-package org.redkale.schedule.spi;
+package org.redkale.scheduled.spi;
 
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
@@ -36,9 +36,8 @@ import org.redkale.annotation.Resource;
 import org.redkale.annotation.ResourceType;
 import org.redkale.boot.Application;
 import org.redkale.net.sncp.Sncp;
-import org.redkale.schedule.ScheduleEvent;
+import org.redkale.scheduled.ScheduledEvent;
-import org.redkale.schedule.ScheduleManager;
+import org.redkale.scheduled.Scheduled;
-import org.redkale.schedule.Scheduled;
 import org.redkale.service.LoadMode;
 import org.redkale.service.Local;
 import org.redkale.service.Service;
@@ -46,6 +45,7 @@ import org.redkale.util.AnyValue;
 import org.redkale.util.RedkaleClassLoader;
 import org.redkale.util.RedkaleException;
 import org.redkale.util.Utility;
+import org.redkale.scheduled.ScheduledManager;
 
 /**
  * 定时任务管理器
@@ -58,8 +58,8 @@ import org.redkale.util.Utility;
 @Local
 @Component
 @AutoLoad(false)
-@ResourceType(ScheduleManager.class)
+@ResourceType(ScheduledManager.class)
-public class ScheduleManagerService implements ScheduleManager, Service {
+public class ScheduleManagerService implements ScheduledManager, Service {
 
     protected final Logger logger = Logger.getLogger(this.getClass().getSimpleName());
 
@@ -157,10 +157,10 @@ public class ScheduleManagerService implements ScheduleManager, Service {
                     methodKeys.add(mk);
                     if (method.getParameterCount() != 0
                             && !(method.getParameterCount() == 1
-                                    && method.getParameterTypes()[0] == ScheduleEvent.class)) {
+                                    && method.getParameterTypes()[0] == ScheduledEvent.class)) {
                         throw new RedkaleException(
                                 "@" + Scheduled.class.getSimpleName() + " must be on non-parameter or "
-                                        + ScheduleEvent.class.getSimpleName() + "-parameter method, but on " + method);
+                                        + ScheduledEvent.class.getSimpleName() + "-parameter method, but on " + method);
                     }
                     ScheduledTask task = schedule(ref, method, remoteMode);
                     // 时间没配置: task=null
@@ -251,7 +251,7 @@ public class ScheduleManagerService implements ScheduleManager, Service {
         return null;
     }
 
-    protected Function<ScheduleEvent, Object> createFuncJob(final WeakReference ref, Method method) {
+    protected Function<ScheduledEvent, Object> createFuncJob(final WeakReference ref, Method method) {
         try {
             if (!Modifier.isPublic(method.getModifiers())) {
                 method.setAccessible(true);
@@ -338,7 +338,7 @@ public class ScheduleManagerService implements ScheduleManager, Service {
 
         protected ScheduledFuture future;
 
-        protected final ScheduleEvent event;
+        protected final ScheduledEvent event;
 
         protected final Map<String, Object> eventMap;
 
@@ -353,7 +353,7 @@ public class ScheduleManagerService implements ScheduleManager, Service {
             this.name = name;
             this.method = method;
             this.eventMap = method.getParameterCount() == 0 ? null : new HashMap<>();
-            this.event = eventMap == null ? null : new ScheduleEvent(eventMap);
+            this.event = eventMap == null ? null : new ScheduledEvent(eventMap);
         }
 
         public void init() {
@@ -389,7 +389,7 @@ public class ScheduleManagerService implements ScheduleManager, Service {
 
     protected class FixedTask extends ScheduledTask implements Runnable {
 
-        private final Function<ScheduleEvent, Object> delegate;
+        private final Function<ScheduledEvent, Object> delegate;
 
         private final long fixedDelay;
 
@@ -447,7 +447,7 @@ public class ScheduleManagerService implements ScheduleManager, Service {
 
     protected class CronTask extends ScheduledTask implements Runnable {
 
-        private final Function<ScheduleEvent, Object> delegate;
+        private final Function<ScheduledEvent, Object> delegate;
 
         private final CronExpression cron;
 

src/main/java/org/redkale/scheduled/spi/ScheduledManagerProvider.java

@@ -0,0 +1,17 @@
+/*
+ *
+ */
+package org.redkale.scheduled.spi;
+
+import org.redkale.scheduled.ScheduledManager;
+import org.redkale.util.InstanceProvider;
+
+/**
+ * 自定义的ScheduledManager加载器, 如果标记@Priority加载器的优先级需要大于1000， 1000以下预留给官方加载器
+ *
+ * <p>详情见: https://redkale.org
+ *
+ * @author zhangjx
+ * @since 2.8.0
+ */
+public interface ScheduledManagerProvider extends InstanceProvider<ScheduledManager> {}

src/main/java/org/redkale/scheduled/spi/ScheduledModuleEngine.java

@@ -1,7 +1,7 @@
 /*
  *
  */
-package org.redkale.schedule.spi;
+package org.redkale.scheduled.spi;
 
 import java.util.ArrayList;
 import java.util.Iterator;
@@ -9,22 +9,24 @@ import java.util.List;
 import java.util.ServiceLoader;
 import org.redkale.boot.Application;
 import org.redkale.boot.ModuleEngine;
-import org.redkale.schedule.ScheduleManager;
+import org.redkale.scheduled.ScheduledManager;
 import org.redkale.service.Service;
 import org.redkale.util.AnyValue;
 import org.redkale.util.InstanceProvider;
 import org.redkale.util.RedkaleClassLoader;
 
 /** @author zhangjx */
-public class ScheduleModuleEngine extends ModuleEngine {
+public class ScheduledModuleEngine extends ModuleEngine {
+
+    protected static final String CONFIG_NAME = "scheduled";
 
     // 全局定时任务管理器
-    private ScheduleManager scheduleManager;
+    private ScheduledManager scheduledManager;
 
     // 配置
     protected AnyValue config;
 
-    public ScheduleModuleEngine(Application application) {
+    public ScheduledModuleEngine(Application application) {
         super(application);
     }
 
@@ -39,7 +41,7 @@ public class ScheduleModuleEngine extends ModuleEngine {
      */
     @Override
     public AnyValue.MergeEnum mergeAppConfigStrategy(String path, String key, AnyValue val1, AnyValue val2) {
-        if ("".equals(path) && "schedule".equals(key)) {
+        if ("".equals(path) && CONFIG_NAME.equals(key)) {
             return AnyValue.MergeEnum.REPLACE;
         }
         return null;
@@ -49,15 +51,15 @@ public class ScheduleModuleEngine extends ModuleEngine {
     @Override
     public void onAppPostInit() {
         // 设置定时管理器
-        this.config = application.getAppConfig().getAnyValue("schedule");
+        this.config = application.getAppConfig().getAnyValue(CONFIG_NAME);
-        this.scheduleManager = createManager(this.config);
+        this.scheduledManager = createManager(this.config);
         if (!application.isCompileMode()) {
-            this.resourceFactory.inject(this.scheduleManager);
+            this.resourceFactory.inject(this.scheduledManager);
-            if (this.scheduleManager instanceof Service) {
+            if (this.scheduledManager instanceof Service) {
-                ((Service) this.scheduleManager).init(this.config);
+                ((Service) this.scheduledManager).init(this.config);
             }
         }
-        this.resourceFactory.register("", ScheduleManager.class, this.scheduleManager);
+        this.resourceFactory.register("", ScheduledManager.class, this.scheduledManager);
     }
 
     /**
@@ -67,7 +69,7 @@ public class ScheduleModuleEngine extends ModuleEngine {
      */
     @Override
     public void onServicePostInit(Service service) {
-        this.scheduleManager.schedule(service);
+        this.scheduledManager.schedule(service);
     }
 
     /**
@@ -77,48 +79,48 @@ public class ScheduleModuleEngine extends ModuleEngine {
      */
     @Override
     public void onServicePreDestroy(Service service) {
-        this.scheduleManager.unschedule(service);
+        this.scheduledManager.unschedule(service);
     }
 
     /** 服务全部启动前被调用 */
     @Override
     public void onServersPreStart() {
-        if (this.scheduleManager instanceof ScheduleManagerService) {
+        if (this.scheduledManager instanceof ScheduleManagerService) {
-            ((ScheduleManagerService) this.scheduleManager).onServersPreStart();
+            ((ScheduleManagerService) this.scheduledManager).onServersPreStart();
         }
     }
 
     /** 服务全部启动后被调用 */
     @Override
     public void onServersPostStart() {
-        if (this.scheduleManager instanceof ScheduleManagerService) {
+        if (this.scheduledManager instanceof ScheduleManagerService) {
-            ((ScheduleManagerService) this.scheduleManager).onServersPostStart();
+            ((ScheduleManagerService) this.scheduledManager).onServersPostStart();
         }
     }
 
     /** 进入Application.shutdown方法被调用 */
     @Override
     public void onAppPreShutdown() {
-        if (!application.isCompileMode() && this.scheduleManager instanceof Service) {
+        if (!application.isCompileMode() && this.scheduledManager instanceof Service) {
-            ((Service) this.scheduleManager).destroy(this.config);
+            ((Service) this.scheduledManager).destroy(this.config);
         }
     }
 
-    private ScheduleManager createManager(AnyValue conf) {
+    private ScheduledManager createManager(AnyValue conf) {
-        Iterator<ScheduleManagerProvider> it = ServiceLoader.load(
+        Iterator<ScheduledManagerProvider> it = ServiceLoader.load(
-                        ScheduleManagerProvider.class, application.getClassLoader())
+                        ScheduledManagerProvider.class, application.getClassLoader())
                 .iterator();
-        RedkaleClassLoader.putServiceLoader(ScheduleManagerProvider.class);
+        RedkaleClassLoader.putServiceLoader(ScheduledManagerProvider.class);
-        List<ScheduleManagerProvider> providers = new ArrayList<>();
+        List<ScheduledManagerProvider> providers = new ArrayList<>();
         while (it.hasNext()) {
-            ScheduleManagerProvider provider = it.next();
+            ScheduledManagerProvider provider = it.next();
             if (provider != null && provider.acceptsConf(conf)) {
                 RedkaleClassLoader.putReflectionPublicConstructors(
                         provider.getClass(), provider.getClass().getName());
                 providers.add(provider);
             }
         }
-        for (ScheduleManagerProvider provider : InstanceProvider.sort(providers)) {
+        for (ScheduledManagerProvider provider : InstanceProvider.sort(providers)) {
             return provider.createInstance();
         }
         return ScheduleManagerService.create(null).enabled(false);

src/main/java/org/redkale/util/RedkaleClassLoader.java

@@ -37,8 +37,8 @@ public class RedkaleClassLoader extends URLClassLoader {
         "org.redkale.asm",
         "org.redkale.boot",
         "org.redkale.boot.watch",
-        "org.redkale.cache",
+        "org.redkale.cached",
-        "org.redkale.cache.spi",
+        "org.redkale.cached.spi",
         "org.redkale.cluster",
         "org.redkale.cluster.spi",
         "org.redkale.convert",
@@ -48,8 +48,8 @@ public class RedkaleClassLoader extends URLClassLoader {
         "org.redkale.convert.proto",
         "org.redkale.convert.spi",
         "org.redkale.inject",
-        "org.redkale.lock",
+        "org.redkale.locked",
-        "org.redkale.lock.spi",
+        "org.redkale.locked.spi",
         "org.redkale.mq",
         "org.redkale.mq.spi",
         "org.redkale.net",
@@ -58,8 +58,8 @@ public class RedkaleClassLoader extends URLClassLoader {
         "org.redkale.net.sncp",
         "org.redkale.persistence",
         "org.redkale.props.spi",
-        "org.redkale.schedule",
+        "org.redkale.scheduled",
-        "org.redkale.schedule.spi",
+        "org.redkale.scheduled.spi",
         "org.redkale.service",
         "org.redkale.source",
         "org.redkale.source.spi",

src/test/java/org/redkale/test/scheduled/ScheduledService.java

@@ -1,14 +1,14 @@
 /*
  *
  */
-package org.redkale.test.schedule;
+package org.redkale.test.scheduled;
 
-import org.redkale.schedule.Scheduled;
+import org.redkale.scheduled.Scheduled;
 import org.redkale.service.Service;
 import org.redkale.util.Times;
 
 /** @author zhangjx */
-public class ScheduleService implements Service {
+public class ScheduledService implements Service {
 
     @Scheduled(cron = "0/1 * * * * ?")
     public void task1() {

src/test/java/org/redkale/test/scheduled/ScheduledTest.java

@@ -1,17 +1,17 @@
 /*
  *
  */
-package org.redkale.test.schedule;
+package org.redkale.test.scheduled;
 
 import org.junit.jupiter.api.Test;
-import org.redkale.schedule.spi.ScheduleManagerService;
+import org.redkale.scheduled.spi.ScheduleManagerService;
 import org.redkale.util.Utility;
 
 /** @author zhangjx */
-public class SchedulingTest {
+public class ScheduledTest {
 
     public static void main(String[] args) throws Throwable {
-        SchedulingTest test = new SchedulingTest();
+        ScheduledTest test = new ScheduledTest();
         test.run();
     }
 
@@ -19,7 +19,7 @@ public class SchedulingTest {
     public void run() throws Exception {
         ScheduleManagerService manager = ScheduleManagerService.create(null);
         manager.init(null);
-        ScheduleService service = new ScheduleService();
+        ScheduledService service = new ScheduledService();
         manager.schedule(service);
         Utility.sleep(3000);
         manager.unschedule(service);