diff --git a/neutrino-core/src/main/java/fun/asgc/neutrino/core/aop/support/AsyncInterceptor.java b/neutrino-core/src/main/java/fun/asgc/neutrino/core/aop/support/AsyncInterceptor.java index d3cb678a..ed6ce1be 100644 --- a/neutrino-core/src/main/java/fun/asgc/neutrino/core/aop/support/AsyncInterceptor.java +++ b/neutrino-core/src/main/java/fun/asgc/neutrino/core/aop/support/AsyncInterceptor.java @@ -23,6 +23,7 @@ package fun.asgc.neutrino.core.aop.support; import fun.asgc.neutrino.core.aop.Invocation; import fun.asgc.neutrino.core.aop.interceptor.Interceptor; +import fun.asgc.neutrino.core.base.CustomThreadFactory; import java.util.concurrent.*; import java.util.concurrent.atomic.AtomicInteger; @@ -34,7 +35,7 @@ import java.util.concurrent.atomic.AtomicInteger; */ public class AsyncInterceptor implements Interceptor { private static final ExecutorService executorService = new ThreadPoolExecutor(10, 50, - 10L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(), new AsyncThreadFactory()); + 10L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(), new CustomThreadFactory("Async")); @Override public void intercept(Invocation inv) throws Exception { @@ -46,31 +47,4 @@ public class AsyncInterceptor implements Interceptor { } }); } - - static class AsyncThreadFactory implements ThreadFactory { - private static final AtomicInteger poolNumber = new AtomicInteger(1); - private final ThreadGroup group; - private final AtomicInteger threadNumber = new AtomicInteger(1); - private final String namePrefix; - - AsyncThreadFactory() { - SecurityManager s = System.getSecurityManager(); - group = (s != null) ? s.getThreadGroup() : - Thread.currentThread().getThreadGroup(); - namePrefix = "AsyncPool-" + poolNumber.getAndIncrement() + "-thread-"; - } - - @Override - public Thread newThread(Runnable r) { - Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(), - 0); - if (t.isDaemon()) { - t.setDaemon(false); - } - if (t.getPriority() != Thread.NORM_PRIORITY) { - t.setPriority(Thread.NORM_PRIORITY); - } - return t; - } - } } diff --git a/neutrino-core/src/main/java/fun/asgc/neutrino/core/base/CustomThreadFactory.java b/neutrino-core/src/main/java/fun/asgc/neutrino/core/base/CustomThreadFactory.java new file mode 100644 index 00000000..dcbd5e61 --- /dev/null +++ b/neutrino-core/src/main/java/fun/asgc/neutrino/core/base/CustomThreadFactory.java @@ -0,0 +1,55 @@ +/** + * Copyright (c) 2022 aoshiguchen + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package fun.asgc.neutrino.core.base; + +import java.util.concurrent.ThreadFactory; +import java.util.concurrent.atomic.AtomicInteger; + +/** + * + * @author: aoshiguchen + * @date: 2022/9/4 + */ +public class CustomThreadFactory implements ThreadFactory { + private final ThreadGroup group; + private final AtomicInteger threadNumber = new AtomicInteger(1); + private final String namePrefix; + + public CustomThreadFactory(String prefix) { + SecurityManager s = System.getSecurityManager(); + group = (s != null) ? s.getThreadGroup() : + Thread.currentThread().getThreadGroup(); + namePrefix = prefix + "-thread-"; + } + + @Override + public Thread newThread(Runnable r) { + Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(), 0); + if (t.isDaemon()) { + t.setDaemon(false); + } + if (t.getPriority() != Thread.NORM_PRIORITY) { + t.setPriority(Thread.NORM_PRIORITY); + } + return t; + } +} diff --git a/neutrino-core/src/main/java/fun/asgc/neutrino/core/bean/AbstractBeanFactory.java b/neutrino-core/src/main/java/fun/asgc/neutrino/core/bean/AbstractBeanFactory.java index 960cba42..dad96d35 100644 --- a/neutrino-core/src/main/java/fun/asgc/neutrino/core/bean/AbstractBeanFactory.java +++ b/neutrino-core/src/main/java/fun/asgc/neutrino/core/bean/AbstractBeanFactory.java @@ -21,6 +21,7 @@ */ package fun.asgc.neutrino.core.bean; +import fun.asgc.neutrino.core.base.CustomThreadFactory; import fun.asgc.neutrino.core.context.Environment; import fun.asgc.neutrino.core.context.LifeCycle; import fun.asgc.neutrino.core.context.LifeCycleManager; @@ -71,7 +72,7 @@ public abstract class AbstractBeanFactory implements BeanFactory, BeanRegistry, /** * 调度器 */ - private static final ScheduledExecutorService scheduledExecutor = Executors.newSingleThreadScheduledExecutor(new BeanFactoryThreadFactory()); + private static final ScheduledExecutorService scheduledExecutor = Executors.newSingleThreadScheduledExecutor(new CustomThreadFactory("BeanFactory")); public AbstractBeanFactory(String name) { this(null, name); @@ -566,31 +567,4 @@ public abstract class AbstractBeanFactory implements BeanFactory, BeanRegistry, () -> environment ); } - - static class BeanFactoryThreadFactory implements ThreadFactory { - private static final AtomicInteger poolNumber = new AtomicInteger(1); - private final ThreadGroup group; - private final AtomicInteger threadNumber = new AtomicInteger(1); - private final String namePrefix; - - BeanFactoryThreadFactory() { - SecurityManager s = System.getSecurityManager(); - group = (s != null) ? s.getThreadGroup() : - Thread.currentThread().getThreadGroup(); - namePrefix = "BeanFactoryPool-" + poolNumber.getAndIncrement() + "-thread-"; - } - - @Override - public Thread newThread(Runnable r) { - Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(), - 0); - if (t.isDaemon()) { - t.setDaemon(false); - } - if (t.getPriority() != Thread.NORM_PRIORITY) { - t.setPriority(Thread.NORM_PRIORITY); - } - return t; - } - } } diff --git a/neutrino-proxy-server/src/main/java/fun/asgc/neutrino/proxy/server/base/rest/config/JobConfig.java b/neutrino-proxy-server/src/main/java/fun/asgc/neutrino/proxy/server/base/rest/config/JobConfig.java index 68287ae4..475e035d 100644 --- a/neutrino-proxy-server/src/main/java/fun/asgc/neutrino/proxy/server/base/rest/config/JobConfig.java +++ b/neutrino-proxy-server/src/main/java/fun/asgc/neutrino/proxy/server/base/rest/config/JobConfig.java @@ -24,15 +24,14 @@ package fun.asgc.neutrino.proxy.server.base.rest.config; import fun.asgc.neutrino.core.annotation.Autowired; import fun.asgc.neutrino.core.annotation.Bean; import fun.asgc.neutrino.core.annotation.Component; +import fun.asgc.neutrino.core.base.CustomThreadFactory; import fun.asgc.neutrino.core.quartz.DefaultJobSource; import fun.asgc.neutrino.core.quartz.JobExecutor; import fun.asgc.neutrino.proxy.server.service.JobLogService; import java.util.concurrent.LinkedBlockingQueue; -import java.util.concurrent.ThreadFactory; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; -import java.util.concurrent.atomic.AtomicInteger; /** * @@ -48,35 +47,9 @@ public class JobConfig { public JobExecutor jobExecutor() { JobExecutor executor = new JobExecutor(); executor.setJobSource(new DefaultJobSource()); - executor.setThreadPoolExecutor(new ThreadPoolExecutor(5, 20, 10L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(), new JobThreadFactory())); + executor.setThreadPoolExecutor(new ThreadPoolExecutor(5, 20, 10L, TimeUnit.SECONDS, + new LinkedBlockingQueue<>(), new CustomThreadFactory("JobPool"))); executor.setJobCallback(jobLogService); return executor; } - - static class JobThreadFactory implements ThreadFactory { - private static final AtomicInteger poolNumber = new AtomicInteger(1); - private final ThreadGroup group; - private final AtomicInteger threadNumber = new AtomicInteger(1); - private final String namePrefix; - - JobThreadFactory() { - SecurityManager s = System.getSecurityManager(); - group = (s != null) ? s.getThreadGroup() : - Thread.currentThread().getThreadGroup(); - namePrefix = "JobPool-" + poolNumber.getAndIncrement() + "-thread-"; - } - - @Override - public Thread newThread(Runnable r) { - Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(), - 0); - if (t.isDaemon()) { - t.setDaemon(false); - } - if (t.getPriority() != Thread.NORM_PRIORITY) { - t.setPriority(Thread.NORM_PRIORITY); - } - return t; - } - } }