org.springframework.scheduling.concurrent.CustomizableThreadFactory Java Examples

@Before
public void init() {
    TimeLimiterConfig timeLimiterConfig = TimeLimiterConfig.custom()
            .timeoutDuration(Duration.ofSeconds(1))
            .cancelRunningFuture(true)
            .build();
     timeLimiter = TimeLimiter.of(timeLimiterConfig);

    CustomizableThreadFactory factory = new CustomizableThreadFactory("timeLimiter-");
    factory.setDaemon(true);
    executorService = Executors.newCachedThreadPool(factory);

    CircuitBreakerConfig circuitBreakerConfig = CircuitBreakerConfig
            .custom()
            .enableAutomaticTransitionFromOpenToHalfOpen()
            .failureRateThreshold(50)
            .ringBufferSizeInClosedState(10)
            .ringBufferSizeInHalfOpenState(2)
            .build();

    circuitBreaker = CircuitBreaker.of("backendName", circuitBreakerConfig);
}
 

@Bean
@ConditionalOnMissingBean(HttpClientConnectionManager.class)
public HttpClientConnectionManager createConnectionManager(
        ApacheHttpClientConnectionManagerFactory connectionManagerFactory) {
    final HttpClientConnectionManager connectionManager = connectionManagerFactory
            .newConnectionManager(httpClientProperties.isDisableSslValidation(), httpClientProperties.getMaxConnections(),
                    httpClientProperties.getMaxConnectionsPerRoute(),
                    httpClientProperties.getTimeToLive(),
                    httpClientProperties.getTimeToLiveUnit(), registryBuilder);

    CustomizableThreadFactory customizableThreadFactory = new CustomizableThreadFactory("RaptorHttpClient.connectionManager.schedule");
    customizableThreadFactory.setDaemon(true);
    connectionManagerSchedule = new ScheduledThreadPoolExecutor(1, customizableThreadFactory);
    connectionManagerSchedule.scheduleAtFixedRate(new Runnable() {
        @Override
        public void run() {
            connectionManager.closeExpiredConnections();
        }
    }, 30000, httpClientProperties.getConnectionTimerRepeat(), TimeUnit.MILLISECONDS);
    return connectionManager;
}
 

/**
 * 允许用户自定义线程池
 *
 * @return 线程池服务
 */
@Bean(name = "aggregateExecutorService")
@ConditionalOnMissingBean(name = "aggregateExecutorService",value=ExecutorService.class)
public ExecutorService aggregateExecutorService() {
    return new ThreadPoolExecutor(
            properties.getThreadNumber(),
            properties.getThreadNumber() ,
            2L, TimeUnit.HOURS,
            new LinkedBlockingDeque<>(properties.getQueueSize()),
            new CustomizableThreadFactory(properties.getThreadPrefix()));
}
 

/**
 * Instantiates a new async executor service impl.
 */
public AsyncExecutorServiceImpl() {
	super(MIN_THREAD_POOL_SIZE, MAX_THREAD_POOL_SIZE, KEEP_ALIVE_TIME,
			TimeUnit.SECONDS, new SynchronousQueue<Runnable>(),
			new CustomizableThreadFactory());
	ThreadFactory factory = this.getThreadFactory();
	if (factory instanceof CustomizableThreadFactory) {
		CustomizableThreadFactory customizableThreadFactory = (CustomizableThreadFactory) factory;
		customizableThreadFactory
				.setThreadNamePrefix("AnkushProgressAwareThread_");
		customizableThreadFactory.setDaemon(true);
	}
}
 

@Bean(destroyMethod = "shutdown")
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public ScheduledExecutorService scheduledExecutorService() {
    ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(properties.getCorePoolSize());

    executor.setMaximumPoolSize(properties.getMaxPoolSize());

    executor.setThreadFactory(new CustomizableThreadFactory(properties.getThreadNamePrefix()));

    executor.setRejectedExecutionHandler(getConfiguredRejectedExecutionHandler());
    return executor;
}
 

@Bean(destroyMethod = "shutdown")
public ExecutorService executor(final Tracer tracer) {
    return new TracedExecutorService(
            ThreadPoolExecutors.builder()
                .withoutQueue()
                .elasticSize(1, 20)
                .keepAlive(1, MINUTES)
                .threadFactory(new CustomizableThreadFactory("http-example-"))
                .build(),
            tracer);
}
 

public static ThreadPoolExecutor create(
        final String id,
        final Threads threads) {

    final TimeSpan keepAlive = threads.getKeepAlive();
    return configure(threads)
            .keepAlive(keepAlive.getAmount(), keepAlive.getUnit())
            .threadFactory(new CustomizableThreadFactory("http-" + id + "-"))
            .build();
}
 

@Autowired
Watchdog(List<LimitExcessListener> listeners) {
    this.listeners = Collections.unmodifiableList(new ArrayList<>(listeners));
    //we need executor which cannot blocked by unknown task
    // also in health() we need to check for hangs tasks and report it
    this.scheduledExecutorService = Executors.newSingleThreadScheduledExecutor(new CustomizableThreadFactory("watchdog-"));
}
 

@Bean
ExecutorService mailSenderExecutor() {
    return new ThreadPoolExecutor(2, 2,
      0L, TimeUnit.MILLISECONDS,
      new ArrayBlockingQueue<Runnable>(queueCapacity),
      new CustomizableThreadFactory("MailSender"));
}
 

private static Executor createAsyncExecutor()
{
	final CustomizableThreadFactory asyncThreadFactory = new CustomizableThreadFactory(DocumentCacheInvalidationDispatcher.class.getSimpleName());
	asyncThreadFactory.setDaemon(true);

	return Executors.newSingleThreadExecutor(asyncThreadFactory);
}
 

public LookupCacheInvalidationDispatcher()
{
	final CustomizableThreadFactory asyncThreadFactory = new CustomizableThreadFactory(LookupCacheInvalidationDispatcher.class.getSimpleName());
	asyncThreadFactory.setDaemon(true);

	async = Executors.newSingleThreadExecutor(asyncThreadFactory);
}
 

public RedisLockFactory(RedisTemplate redisTemplate, LockHandler lockHandler,int scheduledPoolSize) {
    CustomizableThreadFactory threadFactory=new CustomizableThreadFactory("redis-lock");
    threadFactory.setDaemon(true);
    this.redisTemplate = redisTemplate;
    this.lockHandler = lockHandler;
    scheduledThreadPoolExecutor=new ScheduledThreadPoolExecutor(scheduledPoolSize,threadFactory);
}
 

public CircuitBreakerCore(CircuitBreakerManager manager) {
    this.manager = manager;
    CustomizableThreadFactory factory = new CustomizableThreadFactory();
    factory.setDaemon(true);
    factory.setThreadNamePrefix("circuit-breaker-");
    executorService = Executors.newCachedThreadPool(factory);
}
 

/**
 * 自定义ExecutorService, 替代aggregator库使用的executorService
 * @return
 */
@Bean
public ExecutorService aggregateExecutorService() {
    return new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(),Runtime.getRuntime().availableProcessors() * 2 ,
            2L, TimeUnit.HOURS,
            new LinkedBlockingDeque<>(1024),
            new CustomizableThreadFactory("example-async"));
}
 

@Bean(destroyMethod="shutdown")
public Executor taskScheduler(NodeSettings nodeSettings) {

	scheduledExecutorService = Executors.newScheduledThreadPool(nodeSettings.getNodes().size(), new CustomizableThreadFactory("eventeum-scheduler"));
	return  scheduledExecutorService;
}
 

@Bean
public ScheduledExecutorService executorService() {
    return Executors.newScheduledThreadPool(10, new CustomizableThreadFactory("my-thread"));
}
 

MyTaskScheduler() {
    super(Executors.newScheduledThreadPool(10, new CustomizableThreadFactory("my-thread")));
}
 

MyTaskScheduler() {
    super(Executors.newScheduledThreadPool(10, new CustomizableThreadFactory("my-thread")));
}
 

@Bean
public Executor taskExecutor() {
	return Executors.newSingleThreadExecutor(new CustomizableThreadFactory("Custom-"));
}
 

@Bean("customFixedThreadPool")
public ExecutorService customFixedThreadPool() {
    return Executors.newFixedThreadPool(2,new CustomizableThreadFactory("customFixedThreadPool"));
}
 

@Bean
public Executor taskExecutor() {
	return Executors.newSingleThreadExecutor(new CustomizableThreadFactory("Custom-"));
}
 

public void initThreadPool() {
    CustomizableThreadFactory ctf = new CustomizableThreadFactory();
    ctf.setDaemon(true);
    ctf.setThreadNamePrefix(getTransportName()+"-Publisher-");
    threadPool = new JMXReportingThreadPoolExecutor(threadPoolSize, threadPoolSize, 0, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(), ctf);
}
 

/**
 * Bean method to create a thread factory that creates daemon threads.
 * <code>
 * <bean id="pollingThreadFactory" class="org.springframework.scheduling.concurrent.CustomizableThreadFactory">
 * <constructor-arg value="polling-"/>
 * </bean></code>
 */
@Bean(name = "pollingThreadFactory")
public ThreadFactory getPollingThreadFactory() {
    CustomizableThreadFactory tf = new CustomizableThreadFactory("polling-");
    tf.setDaemon(true);
    return tf;
}