org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler

/**
 * DelayTimer
 *
 * @author yizzuide
 * @since 1.15.0
 * @version 3.8.0
 * Create at 2019/11/16 18:57
 */
public clreplaced DelayTimer implements ApplicationListener<ApplicationStartedEvent> {

    @Autowired
    private IceProperties props;

    @Autowired
    private ThreadPoolTaskScheduler taskScheduler;

    @Autowired
    private DelegatingDelayJobHandler delegatingDelayJobHandler;

    @Override
    public void onApplicationEvent(@NonNull ApplicationStartedEvent event) {
        taskScheduler.scheduleWithFixedDelay(delegatingDelayJobHandler, props.getDelayBucketPollRate());
    }
}

public void setSockJsTaskScheduler(ThreadPoolTaskScheduler sockJsTaskScheduler) {
    this.sockJsTaskScheduler = sockJsTaskScheduler.getScheduledThreadPoolExecutor();
    this.loggingTask = initLoggingTask(TimeUnit.MINUTES.toMillis(1));
}

/**
 * Integration tests for {@link LifecycleAwareSessionManager}.
 *
 * @author Mark Paluch
 */
clreplaced LifecycleAwareSessionManagerIntegrationTests extends IntegrationTestSupport {

    private ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();

    @BeforeEach
    void before() {
        this.taskScheduler.afterPropertiesSet();
    }

    @AfterEach
    void tearDown() {
        this.taskScheduler.destroy();
    }

    @Test
    void shouldLogin() {
        LoginToken loginToken = createLoginToken();
        TokenAuthentication tokenAuthentication = new TokenAuthentication(loginToken);
        LifecycleAwareSessionManager sessionManager = new LifecycleAwareSessionManager(tokenAuthentication, this.taskScheduler, prepare().getRestTemplate());
        replacedertThat(sessionManager.getSessionToken()).isSameAs(loginToken);
    }

    // Expect no exception to be thrown.
    @Test
    void shouldRenewToken() {
        VaultTokenOperations tokenOperations = prepare().getVaultOperations().opsForToken();
        VaultTokenRequest tokenRequest = // 
        VaultTokenRequest.builder().renewable().ttl(1, // 
        TimeUnit.HOURS).explicitMaxTtl(10, // 
        TimeUnit.HOURS).build();
        VaultToken token = tokenOperations.create(tokenRequest).getToken();
        TokenAuthentication tokenAuthentication = new TokenAuthentication(LoginToken.renewable(token.getToken().toCharArray(), Duration.ZERO));
        final AtomicInteger counter = new AtomicInteger();
        LifecycleAwareSessionManager sessionManager = new LifecycleAwareSessionManager(tokenAuthentication, this.taskScheduler, prepare().getRestTemplate()) {

            @Override
            public VaultToken getSessionToken() {
                if (counter.getAndIncrement() > 0) {
                    throw new IllegalStateException();
                }
                return super.getSessionToken();
            }
        };
        sessionManager.getSessionToken();
        sessionManager.renewToken();
    }

    @Test
    void shouldRevokeOnDisposal() {
        final LoginToken loginToken = createLoginToken();
        TokenAuthentication tokenAuthentication = new TokenAuthentication(loginToken);
        LifecycleAwareSessionManager sessionManager = new LifecycleAwareSessionManager(tokenAuthentication, this.taskScheduler, prepare().getRestTemplate());
        sessionManager.getSessionToken();
        sessionManager.destroy();
        prepare().getVaultOperations().doWithSession(restOperations -> {
            try {
                restOperations.getForEnreplacedy("auth/token/lookup/{token}", Map.clreplaced, loginToken.toCharArray());
                fail("Missing HttpStatusCodeException");
            } catch (HttpStatusCodeException e) {
                // Compatibility across Vault versions.
                replacedertThat(e.getStatusCode()).isIn(HttpStatus.BAD_REQUEST, HttpStatus.NOT_FOUND, HttpStatus.FORBIDDEN);
            }
            return null;
        });
    }

    private LoginToken createLoginToken() {
        VaultTokenOperations tokenOperations = prepare().getVaultOperations().opsForToken();
        VaultToken token = tokenOperations.createOrphan().getToken();
        return LoginToken.of(token.getToken());
    }
}

public abstract clreplaced AbstractStatusTrigger implements InitializingBean, DisposableBean {

    protected final ThreadPoolTaskScheduler taskScheduler;

    public abstract void onApplicationReady(ApplicationReadyEvent event);

    public abstract void onClosedContext(ContextClosedEvent event);

    public abstract void stopUpdateStatus();

    public AbstractStatusTrigger(ThreadPoolTaskScheduler taskScheduler) {
        this.taskScheduler = taskScheduler;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        taskScheduler.afterPropertiesSet();
    }

    @Override
    public void destroy() throws DestroyFailedException {
        taskScheduler.destroy();
    }
}

public void setSockJsTaskScheduler(ThreadPoolTaskScheduler sockJsTaskScheduler) {
    this.sockJsTaskScheduler = sockJsTaskScheduler.getScheduledThreadPoolExecutor();
    this.loggingTask = initLoggingTask(1 * 60 * 1000);
}

public void setTaskScheduler(ThreadPoolTaskScheduler taskScheduler) {
    this.taskScheduler = taskScheduler;
}

@Test
public void shutdownWhenDoesNotOwnSchedulerDoesNotShutdownScheduler() {
    ThreadPoolTaskScheduler otherScheduler = mockScheduler(ThreadPoolTaskScheduler.clreplaced);
    PrometheusPushGatewayManager manager = new PrometheusPushGatewayManager(this.pushGateway, this.registry, otherScheduler, this.pushRate, "job", this.groupingKey, null);
    manager.shutdown();
    verify(otherScheduler, never()).shutdown();
}

@Test
public void additionalCustomizersShouldAddToExisting() {
    TaskSchedulerCustomizer customizer1 = mock(TaskSchedulerCustomizer.clreplaced);
    TaskSchedulerCustomizer customizer2 = mock(TaskSchedulerCustomizer.clreplaced);
    ThreadPoolTaskScheduler scheduler = this.builder.customizers(customizer1).additionalCustomizers(customizer2).build();
    verify(customizer1).customize(scheduler);
    verify(customizer2).customize(scheduler);
}

@Test
public void customizersShouldApply() {
    TaskSchedulerCustomizer customizer = mock(TaskSchedulerCustomizer.clreplaced);
    ThreadPoolTaskScheduler scheduler = this.builder.customizers(customizer).build();
    verify(customizer).customize(scheduler);
}

@Test
public void threadNamePrefixShouldApply() {
    ThreadPoolTaskScheduler scheduler = this.builder.threadNamePrefix("test-").build();
    replacedertThat(scheduler.getThreadNamePrefix()).isEqualTo("test-");
}

@Test
public void customizersShouldBeAppliedLast() {
    ThreadPoolTaskScheduler scheduler = spy(new ThreadPoolTaskScheduler());
    this.builder.poolSize(4).threadNamePrefix("test-").additionalCustomizers((taskScheduler) -> {
        verify(taskScheduler).setPoolSize(4);
        verify(taskScheduler).setThreadNamePrefix("test-");
    });
    this.builder.configure(scheduler);
}

public clreplaced ValidatorService {

    private static final String NOT_VALID_MSG = "Algorithm is not valid.";

    private final String host;

    private final int port;

    private final Wallet wallet;

    private ThreadPoolTaskScheduler taskScheduler;

    private final Server grpcServer;

    public ValidatorService(DefaultConfig defaultConfig, ConsensusBlockChain blockChain) throws IOException, InvalidCipherTextException {
        this.host = defaultConfig.getString(Constants.VALIDATOR_GRPC_HOST_CONF);
        this.port = defaultConfig.getInt(Constants.VALIDATOR_GRPC_PORT_CONF);
        this.wallet = new Wallet(defaultConfig.getString(Constants.YGGDRASH_KEY_PATH), defaultConfig.getString(Constants.YGGDRASH_KEY_PreplacedWORD));
        setLogLevel(defaultConfig);
        this.taskScheduler = threadPoolTaskScheduler();
        Consensus consensus = blockChain.getConsensus();
        switch(consensus.getAlgorithm()) {
            case "pbft":
                PbftService pbftService = new PbftService(wallet, blockChain, defaultConfig, host, port);
                taskScheduler.schedule(pbftService, new CronTrigger(consensus.getPeriod()));
                try {
                    this.grpcServer = ServerBuilder.forPort(port).addService(new PbftServerStub(pbftService)).addService(new TransactionServiceStub(blockChain, pbftService)).addService(new DiscoveryServiceStub(blockChain, pbftService)).build().start();
                } catch (IOException e) {
                    throw new NotValidateException("Grpc IOException");
                }
                break;
            case "ebft":
                EbftService ebftService = new EbftService(wallet, blockChain, defaultConfig, host, port);
                taskScheduler.schedule(ebftService, new CronTrigger(consensus.getPeriod()));
                try {
                    this.grpcServer = ServerBuilder.forPort(port).addService(new EbftServerStub(ebftService)).addService(new TransactionServiceStub(blockChain, ebftService)).build().start();
                } catch (IOException e) {
                    throw new NotValidateException("Grpc IOException");
                }
                break;
            default:
                throw new NotValidateException(NOT_VALID_MSG);
        }
    }

    private void setLogLevel(DefaultConfig defaultConfig) {
        String logLevel = defaultConfig.getString(Constants.VALIDATOR_LOG_LEVEL_CONF);
        ((ch.qos.logback.clreplacedic.Logger) LoggerFactory.getLogger("io.yggdrash.validator")).setLevel(Level.toLevel(logLevel, Level.INFO));
    }

    private ThreadPoolTaskScheduler threadPoolTaskScheduler() {
        ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
        threadPoolTaskScheduler.setPoolSize(5);
        threadPoolTaskScheduler.setThreadNamePrefix(host + "_" + port + "_");
        threadPoolTaskScheduler.initialize();
        return threadPoolTaskScheduler;
    }

    public static BlockChainBuilder.Factory factory() {
        return (branch, genesisBlock, branchStore, blockChainManager, contractManager) -> {
            Consensus consensus = new Consensus(branch.getConsensus());
            switch(consensus.getAlgorithm()) {
                case "pbft":
                    PbftBlock pbftBlock = new PbftBlock(genesisBlock, PbftMessageSet.forGenesis());
                    return new BlockChainImpl<PbftProto.PbftBlock, PbftMessageSet>(branch, pbftBlock, branchStore, blockChainManager, contractManager);
                case "ebft":
                    EbftBlock ebftBlock = new EbftBlock(genesisBlock);
                    return new BlockChainImpl<EbftProto.EbftBlock, EbftBlock>(branch, ebftBlock, branchStore, blockChainManager, contractManager);
                default:
            }
            throw new NotValidateException(NOT_VALID_MSG);
        };
    }

    public static BlockStoreFactory blockStoreFactory() {
        return (consensusAlgorithm, dbSource) -> {
            switch(consensusAlgorithm) {
                case "pbft":
                    return new PbftBlockStore(dbSource);
                case "ebft":
                    return new EbftBlockStore(dbSource);
                default:
            }
            throw new NotValidateException(NOT_VALID_MSG);
        };
    }

    public void shutdown() {
        grpcServer.shutdown();
    }
}

/**
 * 默认单线程，可能存在堵塞，多给几个线程
 *
 * @return
 */
@Bean
public TaskScheduler taskScheduler() {
    ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
    taskScheduler.setPoolSize(10);
    return taskScheduler;
}

/**
 * 很关键：默认情况下 TaskScheduler 的 poolSize = 1
 *
 * @return 线程池
 */
@Bean
public TaskScheduler taskScheduler() {
    ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
    taskScheduler.setPoolSize(10);
    return taskScheduler;
}

/**
 * STOMP client, see
 * https://docs.spring.io/spring/docs/5.0.8.RELEASE/spring-framework-reference/web.html#websocket-stomp
 * https://docs.spring.io/spring/docs/5.0.8.RELEASE/spring-framework-reference/web.html#websocket-stomp-client
 *
 * @author matthewliu
 * @version 1.0
 * @since 2019/02/14
 */
@Slf4j
public clreplaced Stomp {

    private final static String brokerStomp = "ws://localhost:7000/weevent-broker/stomp";

    private final static String brokerSockJS = "ws://localhost:7000/weevent-broker/sockjs";

    private final static String topic = "com.weevent.test";

    private ThreadPoolTaskScheduler taskScheduler;

    private boolean isConnected;

    public static void main(String[] args) {
        System.out.println("This is WeEvent stomp sample.");
        try {
            Stomp stomp = new Stomp();
            stomp.testOverWebSocket();
        // stomp.testOverSockJS();
        } catch (Exception e) {
            log.error("Exception", e);
        }
    }

    public Stomp() {
        this.taskScheduler = new ThreadPoolTaskScheduler();
        this.taskScheduler.initialize();
        this.isConnected = false;
    }

    private StompSessionHandlerAdapter getWebSocketSessionHandlerAdapter() {
        return new StompSessionHandlerAdapter() {

            @Override
            public void afterConnected(StompSession session, StompHeaders connectedHeaders) {
                log.info("connection open, {}", session.getSessionId());
                session.setAutoReceipt(true);
                // auto subscribe when connected
                log.info("subscribe topic, {}", topic);
                StompHeaders header = new StompHeaders();
                header.setDestination(topic);
                header.set("eventId", WeEvent.OFFSET_LAST);
                header.set("groupId", WeEvent.DEFAULT_GROUP_ID);
                StompSession.Subscription subscription = session.subscribe(header, new StompFrameHandler() {

                    @Override
                    public Type getPayloadType(StompHeaders headers) {
                        return String.clreplaced;
                    }

                    @Override
                    public void handleFrame(StompHeaders headers, Object payload) {
                        log.info("subscribe handleFrame, header: {} payload: {}", headers, payload);
                    }
                });
                log.info("subscribe result, subscription id: {}", subscription.getSubscriptionId());
                // subscription.unsubscribe() when needed
                log.info("send event to topic, {}", topic);
                StompSession.Receiptable receipt = session.send(topic, "hello WeEvent from web socket");
                log.info("send result, receipt id: {}", receipt.getReceiptId());
            }

            @Override
            public void handleException(StompSession session, StompCommand command, StompHeaders headers, byte[] payload, Throwable exception) {
                log.info("connection exception, {} {}", session.getSessionId(), command);
                log.error("exception", exception);
            }

            @Override
            public void handleTransportError(StompSession session, Throwable exception) {
                if (exception instanceof ConnectionLostException || !isConnected) {
                    log.info("connection closed, {}", session.getSessionId());
                    isConnected = false;
                    // do auto reconnect in this handle
                    while (!isConnected) try {
                        // retry every 3 seconds
                        Thread.sleep(3000);
                        // new connect start
                        WebSocketClient webSocketClient = new StandardWebSocketClient();
                        WebSocketStompClient stompClient = new WebSocketStompClient(webSocketClient);
                        stompClient.setMessageConverter(new StringMessageConverter());
                        // for heartbeats
                        stompClient.setTaskScheduler(taskScheduler);
                        ListenableFuture<StompSession> f = stompClient.connect(brokerStomp, this);
                        f.get();
                        // new connect end
                        isConnected = true;
                    } catch (Exception e) {
                        log.error("exception", exception);
                    }
                } else {
                    log.info("connection error, {}", session.getSessionId());
                    log.error("exception", exception);
                }
            }

            @Override
            public void handleFrame(StompHeaders headers, Object payload) {
                log.info("session handleFrame, header: {} payload: {}", headers, payload);
            }
        };
    }

    private void testOverWebSocket() throws InterruptedException {
        // standard web socket transport
        WebSocketClient webSocketClient = new StandardWebSocketClient();
        WebSocketStompClient stompClient = new WebSocketStompClient(webSocketClient);
        // MappingJackson2MessageConverter
        stompClient.setMessageConverter(new StringMessageConverter());
        // for heartbeats
        stompClient.setTaskScheduler(taskScheduler);
        stompClient.connect(brokerStomp, getWebSocketSessionHandlerAdapter());
        Thread.sleep(100000L);
    }

    private StompSessionHandlerAdapter getSockJSSessionHandlerAdapter() {
        return new StompSessionHandlerAdapter() {

            @Override
            public void afterConnected(StompSession session, StompHeaders connectedHeaders) {
                log.info("connection open, {}", session.getSessionId());
                session.setAutoReceipt(true);
                // auto subscribe when connected
                StompHeaders header = new StompHeaders();
                header.setDestination(topic);
                header.set("eventId", WeEvent.OFFSET_LAST);
                header.set("groupId", WeEvent.DEFAULT_GROUP_ID);
                StompSession.Subscription subscription = session.subscribe(header, new StompFrameHandler() {

                    @Override
                    public Type getPayloadType(StompHeaders headers) {
                        return String.clreplaced;
                    }

                    @Override
                    public void handleFrame(StompHeaders headers, Object payload) {
                        log.info("subscribe handleFrame, header: {} payload: {}", headers, payload);
                    }
                });
                log.info("subscribe result, subscription id: {}", subscription.getSubscriptionId());
                // subscription.unsubscribe() when needed
                StompSession.Receiptable receipt = session.send(header, "hello WeEvent from sock js");
                log.info("send result, receipt id: {}", receipt.getReceiptId());
            }

            @Override
            public void handleException(StompSession session, StompCommand command, StompHeaders headers, byte[] payload, Throwable exception) {
                log.info("connection exception, {} {}", session.getSessionId(), command);
                log.error("exception", exception);
            }

            @Override
            public void handleTransportError(StompSession session, Throwable exception) {
                if (exception instanceof ConnectionLostException) {
                    log.info("connection closed, {}", session.getSessionId());
                    // do auto reconnect in this handle
                    while (!isConnected) try {
                        // retry every 3 seconds
                        Thread.sleep(3000);
                        // new connect start
                        // sock js transport
                        List<Transport> transports = new ArrayList<>(2);
                        transports.add(new WebSocketTransport(new StandardWebSocketClient()));
                        transports.add(new RestTemplateXhrTransport());
                        SockJsClient sockjsClient = new SockJsClient(transports);
                        WebSocketStompClient stompClient = new WebSocketStompClient(sockjsClient);
                        // StringMessageConverter
                        stompClient.setMessageConverter(new MappingJackson2MessageConverter());
                        // for heartbeats
                        stompClient.setTaskScheduler(taskScheduler);
                        ListenableFuture<StompSession> f = stompClient.connect(brokerSockJS, this);
                        f.get();
                        // new connect end
                        isConnected = true;
                    } catch (Exception e) {
                        log.error("exception", exception);
                    }
                } else {
                    log.info("connection error, {}", session.getSessionId());
                    log.error("exception", exception);
                }
            }

            @Override
            public void handleFrame(StompHeaders headers, Object payload) {
                log.info("session handleFrame, header: {} payload: {}", headers, payload);
            }
        };
    }

    private void testOverSockJS() throws InterruptedException {
        // sock js transport
        List<Transport> transports = new ArrayList<>(2);
        transports.add(new WebSocketTransport(new StandardWebSocketClient()));
        transports.add(new RestTemplateXhrTransport());
        SockJsClient sockjsClient = new SockJsClient(transports);
        WebSocketStompClient stompClient = new WebSocketStompClient(sockjsClient);
        // StringMessageConverter
        stompClient.setMessageConverter(new MappingJackson2MessageConverter());
        // for heartbeats
        stompClient.setTaskScheduler(taskScheduler);
        stompClient.connect(brokerSockJS, getSockJSSessionHandlerAdapter());
        Thread.sleep(100000L);
    }
}

public clreplaced ScheduledTest extends TestBase {

    @Autowired
    private ThreadPoolTaskScheduler threadPoolTaskScheduler;

    private ScheduledFuture<?> future;

    public clreplaced MyRunnable implements Runnable {

        public void run() {
            System.out.println("MyRunnable.run()，" + new Date());
            System.out.println("begin sync chain data");
            Long currentTime = System.currentTimeMillis();
            // to do  add  more group
            Monitor monitor = new Monitor();
            CompletableFuture<BlockNumber> blockHeightFuture = web3j.getBlockNumber().sendAsync();
            CompletableFuture<PbftView> pbftViewFuture = web3j.getPbftView().sendAsync();
            CompletableFuture<PendingTxSize> pendingTxSizeFuture = web3j.getPendingTxSize().sendAsync();
            try {
                monitor.setBlockHeight(blockHeightFuture.get().getBlockNumber());
                monitor.setPbftView(pbftViewFuture.get().getPbftView());
                monitor.setPendingTransactionCount(pendingTxSizeFuture.get().getPendingTxSize());
                monitor.setTimestamp(currentTime);
                monitor.setGroupId(1);
                System.out.println(monitor);
            } catch (ExecutionException | InterruptedException e) {
                System.out.println("sync chain data error " + e.getMessage());
            }
            System.out.println("insert success =  " + monitor.getId());
        }
    }

    @Bean
    public ThreadPoolTaskScheduler threadPoolTaskScheduler() {
        return new ThreadPoolTaskScheduler();
    }

    @Test
    public void startCron() {
        // ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
        future = threadPoolTaskScheduler.schedule(new MyRunnable(), new CronTrigger("0/5 * * * * *"));
        System.out.println("DynamicTaskController.startCron()");
    }

    @Test
    public void stopCron() {
        if (future != null) {
            future.cancel(true);
        }
        System.out.println("DynamicTaskController.stopCron()");
    }

    @Test
    public void changeCron() {
        // ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
        // 先停止，在开启.
        stopCron();
        future = threadPoolTaskScheduler.schedule(new MyRunnable(), new CronTrigger("*/10 * * * * *"));
        System.out.println("DynamicTaskController.changeCron()");
    }
}

@Test
public void customScheduler() {
    ThreadPoolTaskScheduler scheduler = (ThreadPoolTaskScheduler) this.context.getBean("customScheduler");
    Integer size = (Integer) new DirectFieldAccessor(scheduler).getPropertyValue("poolSize");
    replacedertEquals(new Integer(42), size);
}

@Test
public void defaultScheduler() {
    ThreadPoolTaskScheduler scheduler = (ThreadPoolTaskScheduler) this.context.getBean("defaultScheduler");
    Integer size = (Integer) new DirectFieldAccessor(scheduler).getPropertyValue("poolSize");
    replacedertEquals(new Integer(1), size);
}

@Test
public void threadNamePrefix() {
    ThreadPoolTaskScheduler scheduler = (ThreadPoolTaskScheduler) this.context.getBean("customScheduler");
    replacedertEquals("customScheduler-", scheduler.getThreadNamePrefix());
}

@Bean
public ThreadPoolTaskScheduler heartbeatTaskScheduler() {
    // The following task scheduler is needed to enable heartbeats between server and client in order to detect
    // abnormal termination of either
    ThreadPoolTaskScheduler heartbeatTaskScheduler = new ThreadPoolTaskScheduler();
    heartbeatTaskScheduler.setThreadNamePrefix("websocketHeartbeatTaskScheduler-");
    return heartbeatTaskScheduler;
}

@Bean
public TaskScheduler taskScheduler() {
    ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
    taskScheduler.setPoolSize(50);
    return taskScheduler;
}

@Bean
public TaskScheduler taskScheduler() {
    ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
    taskScheduler.setPoolSize(10);
    return taskScheduler;
}

/**
 * Integration tests for {@link ReactiveLifecycleAwareSessionManager}.
 *
 * @author Mark Paluch
 */
@RequiresVaultVersion("0.6.2")
clreplaced ReactiveLifecycleAwareSessionManagerIntegrationTests extends IntegrationTestSupport {

    private ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();

    @BeforeEach
    void before() {
        this.taskScheduler.afterPropertiesSet();
        if (!prepare().hasAuth("cert")) {
            prepare().mountAuth("cert");
        }
        prepare().getVaultOperations().doWithSession((RestOperationsCallback<Object>) restOperations -> {
            File workDir = findWorkDir();
            String certificate = Files.contentOf(new File(workDir, "ca/certs/client.cert.pem"), StandardCharsets.US_ASCII);
            Map<String, Object> body = new HashMap<>();
            body.put("certificate", certificate);
            body.put("ttl", 2);
            body.put("max_ttl", 2);
            return restOperations.postForEnreplacedy("auth/cert/certs/my-role", body, Map.clreplaced);
        });
    }

    @AfterEach
    void tearDown() {
        this.taskScheduler.destroy();
    }

    @Test
    void shouldLogin() {
        LoginToken loginToken = createLoginToken();
        ReactiveLifecycleAwareSessionManager sessionManager = new ReactiveLifecycleAwareSessionManager(() -> Mono.just(loginToken), this.taskScheduler, prepare().getWebClient());
        // 
        sessionManager.getVaultToken().as(// 
        StepVerifier::create).expectNext(// 
        loginToken).verifyComplete();
    }

    // Expect no exception to be thrown.
    @Test
    void shouldRenewToken() {
        VaultTokenOperations tokenOperations = prepare().getVaultOperations().opsForToken();
        VaultTokenRequest tokenRequest = // 
        VaultTokenRequest.builder().renewable().ttl(1, // 
        TimeUnit.HOURS).explicitMaxTtl(10, // 
        TimeUnit.HOURS).build();
        VaultToken token = tokenOperations.create(tokenRequest).getToken();
        LoginToken loginToken = LoginToken.renewable(token, Duration.ZERO);
        final AtomicInteger counter = new AtomicInteger();
        ReactiveLifecycleAwareSessionManager sessionManager = new ReactiveLifecycleAwareSessionManager(() -> Flux.fromStream(Stream.of((VaultToken) loginToken)).next(), this.taskScheduler, prepare().getWebClient()) {

            @Override
            public Mono<VaultToken> getVaultToken() throws VaultException {
                if (counter.getAndIncrement() > 0) {
                    throw new IllegalStateException();
                }
                return super.getVaultToken();
            }
        };
        // 
        sessionManager.getSessionToken().as(// 
        StepVerifier::create).expectNext(// 
        loginToken).verifyComplete();
        // 
        sessionManager.renewToken().as(// 
        StepVerifier::create).expectNext(// 
        loginToken).verifyComplete();
    }

    @Test
    void shouldRevokeOnDisposal() {
        final LoginToken loginToken = createLoginToken();
        ReactiveLifecycleAwareSessionManager sessionManager = new ReactiveLifecycleAwareSessionManager(() -> Flux.fromStream(Stream.of((VaultToken) loginToken)).next(), this.taskScheduler, prepare().getWebClient());
        // 
        sessionManager.getSessionToken().as(// 
        StepVerifier::create).expectNext(// 
        loginToken).verifyComplete();
        sessionManager.destroy();
        prepare().getVaultOperations().doWithSession(restOperations -> {
            try {
                restOperations.getForEnreplacedy("auth/token/lookup/{token}", Map.clreplaced, loginToken.toCharArray());
                fail("Missing HttpStatusCodeException");
            } catch (HttpStatusCodeException e) {
                // Compatibility across Vault versions.
                replacedertThat(e.getStatusCode()).isIn(HttpStatus.BAD_REQUEST, HttpStatus.NOT_FOUND, HttpStatus.FORBIDDEN);
            }
            return null;
        });
    }

    private LoginToken createLoginToken() {
        VaultTokenOperations tokenOperations = prepare().getVaultOperations().opsForToken();
        VaultToken token = tokenOperations.createOrphan().getToken();
        return LoginToken.of(token.getToken());
    }
}

@Test
public void threadNamePrefix() {
    ThreadPoolTaskScheduler scheduler = (ThreadPoolTaskScheduler) this.context.getBean("customScheduler");
    replacedertThat(scheduler.getThreadNamePrefix()).isEqualTo("customScheduler-");
}

@Test
public void customScheduler() {
    ThreadPoolTaskScheduler scheduler = (ThreadPoolTaskScheduler) this.context.getBean("customScheduler");
    Integer size = (Integer) new DirectFieldAccessor(scheduler).getPropertyValue("poolSize");
    replacedertThat(size).isEqualTo(new Integer(42));
}

@Test
public void defaultScheduler() {
    ThreadPoolTaskScheduler scheduler = (ThreadPoolTaskScheduler) this.context.getBean("defaultScheduler");
    Integer size = (Integer) new DirectFieldAccessor(scheduler).getPropertyValue("poolSize");
    replacedertThat(size).isEqualTo(new Integer(1));
}

@Bean
public TaskScheduler taskScheduler() {
    ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
    scheduler.setPoolSize(5);
    return scheduler;
}

@Bean
public static ThreadPoolTaskScheduler createThreadPoolTaskScheduler() {
    ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
    taskScheduler.setPoolSize(4);
    taskScheduler.setRemoveOnCancelPolicy(true);
    taskScheduler.setBeanName("status-update-pool");
    taskScheduler.setErrorHandler(e -> log.error("error:", e));
    return taskScheduler;
}

/**
 * A traced version of {@code TracedThreadPoolTaskScheduler}.
 *
 * @author cbono
 */
public clreplaced TracedThreadPoolTaskScheduler extends ThreadPoolTaskScheduler {

    private final Tracer tracer;

    private final ThreadPoolTaskScheduler delegate;

    public TracedThreadPoolTaskScheduler(Tracer tracer, ThreadPoolTaskScheduler delegate) {
        this.tracer = tracer;
        this.delegate = delegate;
    }

    @Override
    public void setPoolSize(int poolSize) {
        delegate.setPoolSize(poolSize);
    }

    @Override
    public void setRemoveOnCancelPolicy(boolean removeOnCancelPolicy) {
        delegate.setRemoveOnCancelPolicy(removeOnCancelPolicy);
    }

    @Override
    public void setErrorHandler(ErrorHandler errorHandler) {
        delegate.setErrorHandler(errorHandler);
    }

    @Override
    public ScheduledExecutorService getScheduledExecutor() throws IllegalStateException {
        return delegate.getScheduledExecutor();
    }

    @Override
    public ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor() throws IllegalStateException {
        return delegate.getScheduledThreadPoolExecutor();
    }

    @Override
    public int getPoolSize() {
        return delegate.getPoolSize();
    }

    @Override
    public boolean isRemoveOnCancelPolicy() {
        return delegate.isRemoveOnCancelPolicy();
    }

    @Override
    public int getActiveCount() {
        return delegate.getActiveCount();
    }

    @Override
    public void execute(Runnable task) {
        delegate.execute(new TracedRunnable(task, tracer));
    }

    @Override
    public void execute(Runnable task, long startTimeout) {
        delegate.execute(new TracedRunnable(task, tracer), startTimeout);
    }

    @Override
    public Future<?> submit(Runnable task) {
        return delegate.submit(new TracedRunnable(task, tracer));
    }

    @Override
    public <T> Future<T> submit(Callable<T> task) {
        return delegate.submit(new TracedCallable<>(task, tracer));
    }

    @Override
    public ListenableFuture<?> submitListenable(Runnable task) {
        return delegate.submitListenable(new TracedRunnable(task, tracer));
    }

    @Override
    public <T> ListenableFuture<T> submitListenable(Callable<T> task) {
        return delegate.submitListenable(new TracedCallable<>(task, tracer));
    }

    @Override
    @Nullable
    public ScheduledFuture<?> schedule(Runnable task, Trigger trigger) {
        return delegate.schedule(new TracedRunnable(task, tracer), trigger);
    }

    @Override
    public ScheduledFuture<?> schedule(Runnable task, Date startTime) {
        return delegate.schedule(new TracedRunnable(task, tracer), startTime);
    }

    @Override
    public ScheduledFuture<?> schedule(Runnable task, Instant startTime) {
        return delegate.schedule(new TracedRunnable(task, tracer), startTime);
    }

    @Override
    public ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period) {
        return delegate.scheduleAtFixedRate(new TracedRunnable(task, tracer), startTime, period);
    }

    @Override
    public ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Instant startTime, Duration period) {
        return delegate.scheduleAtFixedRate(new TracedRunnable(task, tracer), startTime, period);
    }

    @Override
    public ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period) {
        return delegate.scheduleAtFixedRate(new TracedRunnable(task, tracer), period);
    }

    @Override
    public ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Duration period) {
        return delegate.scheduleAtFixedRate(new TracedRunnable(task, tracer), period);
    }

    @Override
    public ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay) {
        return delegate.scheduleWithFixedDelay(new TracedRunnable(task, tracer), startTime, delay);
    }

    @Override
    public ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay) {
        return delegate.scheduleWithFixedDelay(new TracedRunnable(task, tracer), delay);
    }

    @Override
    public ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay) {
        return delegate.scheduleWithFixedDelay(new TracedRunnable(task, tracer), startTime, delay);
    }

    @Override
    public ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Duration delay) {
        return delegate.scheduleWithFixedDelay(new TracedRunnable(task, tracer), delay);
    }

    @Override
    public void setThreadFactory(ThreadFactory threadFactory) {
        delegate.setThreadFactory(threadFactory);
    }

    @Override
    public void setThreadNamePrefix(String threadNamePrefix) {
        delegate.setThreadNamePrefix(threadNamePrefix);
    }

    @Override
    public void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler) {
        delegate.setRejectedExecutionHandler(rejectedExecutionHandler);
    }

    @Override
    public void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown) {
        delegate.setWaitForTasksToCompleteOnShutdown(waitForJobsToCompleteOnShutdown);
    }

    @Override
    public void setAwaitTerminationSeconds(int awaitTerminationSeconds) {
        delegate.setAwaitTerminationSeconds(awaitTerminationSeconds);
    }

    @Override
    public void setBeanName(String name) {
        delegate.setBeanName(name);
    }

    @Override
    public void afterPropertiesSet() {
        delegate.afterPropertiesSet();
    }

    @Override
    public void initialize() {
        delegate.initialize();
    }

    @Override
    public void destroy() {
        delegate.destroy();
    }

    @Override
    public void shutdown() {
        delegate.shutdown();
    }

    @Override
    public Thread newThread(Runnable runnable) {
        return delegate.newThread(runnable);
    }

    @Override
    public String getThreadNamePrefix() {
        return delegate.getThreadNamePrefix();
    }

    @Override
    public void setThreadPriority(int threadPriority) {
        delegate.setThreadPriority(threadPriority);
    }

    @Override
    public int getThreadPriority() {
        return delegate.getThreadPriority();
    }

    @Override
    public void setDaemon(boolean daemon) {
        delegate.setDaemon(daemon);
    }

    @Override
    public boolean isDaemon() {
        return delegate.isDaemon();
    }

    @Override
    public void setThreadGroupName(String name) {
        delegate.setThreadGroupName(name);
    }

    @Override
    public void setThreadGroup(ThreadGroup threadGroup) {
        delegate.setThreadGroup(threadGroup);
    }

    @Override
    @Nullable
    public ThreadGroup getThreadGroup() {
        return delegate.getThreadGroup();
    }

    @Override
    public Thread createThread(Runnable runnable) {
        return delegate.createThread(runnable);
    }

    @Override
    public boolean prefersShortLivedTasks() {
        return delegate.prefersShortLivedTasks();
    }
}

@Bean
public ThreadPoolTaskScheduler threadPoolTaskScheduler() {
    ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
    threadPoolTaskScheduler.setThreadNamePrefix("kubeHelperTask-");
    return threadPoolTaskScheduler;
}

@Bean
public TaskScheduler taskScheduler() {
    ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
    scheduler.setThreadNamePrefix("sync-");
    return scheduler;
}

@Bean
public TaskScheduler taskScheduler() {
    ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
    scheduler.setThreadNamePrefix("jdbc-purge-");
    return scheduler;
}

/**
 * @author Joram Barrez
 */
public clreplaced DefaultSpringEventRegistryChangeDetectionExecutor implements EventRegistryChangeDetectionExecutor, DisposableBean {

    protected long initialDelayInMs;

    protected long delayInMs;

    protected TaskScheduler taskScheduler;

    // If non-null, it means the scheduler has been created in this clreplaced
    protected ThreadPoolTaskScheduler threadPoolTaskScheduler;

    protected EventRegistryChangeDetectionManager eventRegistryChangeDetectionManager;

    public DefaultSpringEventRegistryChangeDetectionExecutor(long initialDelayInMs, long delayInMs) {
        this(initialDelayInMs, delayInMs, null);
    }

    public DefaultSpringEventRegistryChangeDetectionExecutor(long initialDelayInMs, long delayInMs, TaskScheduler taskScheduler) {
        this.initialDelayInMs = initialDelayInMs;
        this.delayInMs = delayInMs;
        if (taskScheduler != null) {
            this.taskScheduler = taskScheduler;
        } else {
            createDefaultTaskScheduler();
        }
    }

    protected void createDefaultTaskScheduler() {
        threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
        threadPoolTaskScheduler.setPoolSize(1);
        threadPoolTaskScheduler.setThreadNamePrefix("flowable-event-change-detector-");
        taskScheduler = threadPoolTaskScheduler;
    }

    @Override
    public void initialize() {
        if (threadPoolTaskScheduler != null) {
            threadPoolTaskScheduler.initialize();
        }
        Instant initialInstant = Instant.now().plus(initialDelayInMs, ChronoUnit.MILLIS);
        // Note we cannot use the method with the Instant since it was added in Spring 5.0, and we still want to support 4.3
        taskScheduler.scheduleWithFixedDelay(createChangeDetectionRunnable(), Date.from(initialInstant), delayInMs);
    }

    protected Runnable createChangeDetectionRunnable() {
        return new EventRegistryChangeDetectionRunnable(eventRegistryChangeDetectionManager);
    }

    @Override
    public void shutdown() {
        destroy();
    }

    @Override
    public void destroy() {
        if (threadPoolTaskScheduler != null) {
            threadPoolTaskScheduler.destroy();
        }
    }

    public EventRegistryChangeDetectionManager getEventRegistryChangeDetectionManager() {
        return eventRegistryChangeDetectionManager;
    }

    @Override
    public void setEventRegistryChangeDetectionManager(EventRegistryChangeDetectionManager eventRegistryChangeDetectionManager) {
        this.eventRegistryChangeDetectionManager = eventRegistryChangeDetectionManager;
    }

    public TaskScheduler getTaskScheduler() {
        return taskScheduler;
    }

    public void setTaskScheduler(TaskScheduler taskScheduler) {
        this.taskScheduler = taskScheduler;
    }
}

@Bean
public TaskScheduler taskScheduler() {
    ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
    scheduler.setRemoveOnCancelPolicy(true);
    scheduler.setPoolSize(SCHEDULED_TASKS_POOL_SIZE);
    return scheduler;
}

@Bean
public ThreadPoolTaskScheduler taskScheduler() {
    ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
    scheduler.setPoolSize(3);
    return scheduler;
}

// for scheduled methods (SubmissionMonitor)
@Bean
public TaskScheduler taskScheduler() {
    ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
    scheduler.setRemoveOnCancelPolicy(true);
    scheduler.setPoolSize(1);
    return scheduler;
}

@Bean
public TaskScheduler taskScheduler() {
    ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
    scheduler.setPoolSize(2);
    return scheduler;
}

@Bean
public TaskScheduler taskScheduler() {
    ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
    scheduler.setRemoveOnCancelPolicy(true);
    // For AbstractSchedulingManager's subclreplacedes' tasks
    scheduler.setPoolSize(scheduledPoolSize);
    return scheduler;
}

@Bean
public TaskScheduler taskScheduler() {
    ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
    threadPoolTaskScheduler.setPoolSize(20);
    return threadPoolTaskScheduler;
}

clreplaced LandscapeObserverPoolTest {

    private ThreadPoolTaskScheduler scheduler;

    private LandscapeObserverPool landscapeObserverPool;

    private ScheduledFuture scheduledFuture;

    @BeforeEach
    void setup() {
        scheduler = mock(ThreadPoolTaskScheduler.clreplaced);
        scheduledFuture = mock(ScheduledFuture.clreplaced);
        when(scheduler.scheduleWithFixedDelay(any(Runnable.clreplaced), anyLong())).thenReturn(scheduledFuture);
        landscapeObserverPool = new LandscapeObserverPool(scheduler, 1);
    }

    @Test
    public void schedulesRunnables() {
        InputFormatObserver observer1 = mock(InputFormatObserver.clreplaced);
        InputFormatObserver observer2 = mock(InputFormatObserver.clreplaced);
        InputFormatObserver observer3 = mock(InputFormatObserver.clreplaced);
        // when
        landscapeObserverPool.updateObservers(List.of(observer1, observer2, observer3));
        // then
        verify(scheduler, times(3)).scheduleWithFixedDelay(any(Runnable.clreplaced), eq(1L));
    }

    @Test
    public void stopsScheduledTasks() {
        InputFormatObserver observer1 = mock(InputFormatObserver.clreplaced);
        InputFormatObserver observer2 = mock(InputFormatObserver.clreplaced);
        landscapeObserverPool.updateObservers(List.of(observer1, observer2));
        // when
        InputFormatObserver observer3 = mock(InputFormatObserver.clreplaced);
        InputFormatObserver observer4 = mock(InputFormatObserver.clreplaced);
        landscapeObserverPool.updateObservers(List.of(observer3, observer4));
        // then
        verify(scheduledFuture, times(2)).cancel(eq(true));
    }
}

private ThreadPoolTaskScheduler getTaskScheduler() {
    ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
    taskScheduler.initialize();
    return taskScheduler;
}

@Bean
public TaskScheduler taskScheduler() {
    // Spring提供的定时任务线程池类
    ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
    // 设定最大可用的线程数目
    taskScheduler.setPoolSize(10);
    return taskScheduler;
}

/**
 * 解决同一时间只能一个定时任务执行的问题
 */
@Bean
public TaskScheduler taskScheduler() {
    ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
    taskScheduler.setPoolSize(5);
    return taskScheduler;
}

@Bean
public TaskScheduler taskScheduler() {
    ThreadPoolTaskScheduler scheduling = new ThreadPoolTaskScheduler();
    scheduling.setPoolSize(10);
    scheduling.initialize();
    return scheduling;
}

@Bean
public TaskScheduler taskScheduler() {
    ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
    // 线程池大小
    scheduler.setPoolSize(3);
    // 线程名字前缀
    scheduler.setThreadNamePrefix("task-thread-");
    return scheduler;
}

@Test
public void customizersShouldReplaceExisting() {
    TaskSchedulerCustomizer customizer1 = mock(TaskSchedulerCustomizer.clreplaced);
    TaskSchedulerCustomizer customizer2 = mock(TaskSchedulerCustomizer.clreplaced);
    ThreadPoolTaskScheduler scheduler = this.builder.customizers(customizer1).customizers(Collections.singleton(customizer2)).build();
    verifyZeroInteractions(customizer1);
    verify(customizer2).customize(scheduler);
}

@Test
public void poolSettingsShouldApply() {
    ThreadPoolTaskScheduler scheduler = this.builder.poolSize(4).build();
    replacedertThat(scheduler.getPoolSize()).isEqualTo(4);
}

/**
 * The default TaskScheduler to use if none is registered explicitly via
 * {@link SockJsServiceRegistration#setTaskScheduler}:
 * <pre clreplaced="code">
 * @Configuration
 * @EnableWebSocket
 * public clreplaced WebSocketConfig implements WebSocketConfigurer {
 *
 *   public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
 *     registry.addHandler(myHandler(), "/echo")
 *             .withSockJS()
 *             .setTaskScheduler(myScheduler());
 *   }
 *
 *   // ...
 * }
 * </pre>
 */
@Bean
@Nullable
public TaskScheduler defaultSockJsTaskScheduler() {
    if (initHandlerRegistry().requiresTaskScheduler()) {
        ThreadPoolTaskScheduler threadPoolScheduler = new ThreadPoolTaskScheduler();
        threadPoolScheduler.setThreadNamePrefix("SockJS-");
        threadPoolScheduler.setPoolSize(Runtime.getRuntime().availableProcessors());
        threadPoolScheduler.setRemoveOnCancelPolicy(true);
        this.scheduler = threadPoolScheduler;
    }
    return this.scheduler;
}

@Before
public void setUp() throws Exception {
    logger.debug("Setting up before '" + this.testName.getMethodName() + "'");
    int port = SocketUtils.findAvailableTcpPort(61613);
    this.activeMQBroker = new BrokerService();
    this.activeMQBroker.addConnector("stomp://127.0.0.1:" + port);
    this.activeMQBroker.setStartAsync(false);
    this.activeMQBroker.setPersistent(false);
    this.activeMQBroker.setUseJmx(false);
    this.activeMQBroker.getSystemUsage().getMemoryUsage().setLimit(1024 * 1024 * 5);
    this.activeMQBroker.getSystemUsage().getTempUsage().setLimit(1024 * 1024 * 5);
    this.activeMQBroker.start();
    ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
    taskScheduler.afterPropertiesSet();
    this.client = new ReactorNettyTcpStompClient("127.0.0.1", port);
    this.client.setMessageConverter(new StringMessageConverter());
    this.client.setTaskScheduler(taskScheduler);
}

/**
 * Create a {@link TaskSchedulerWrapper} used by {@link LifecycleAwareSessionManager}
 * and {@link org.springframework.vault.core.lease.SecretLeaseContainer} wrapping
 * {@link ThreadPoolTaskScheduler}. Subclreplacedes may override this method to reuse a
 * different/existing scheduler.
 * @return the {@link TaskSchedulerWrapper} to use. Must not be {@literal null}.
 * @see TaskSchedulerWrapper#fromInstance(ThreadPoolTaskScheduler)
 */
@Bean("vaultThreadPoolTaskScheduler")
public TaskSchedulerWrapper threadPoolTaskScheduler() {
    ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
    threadPoolTaskScheduler.setThreadNamePrefix("spring-vault-ThreadPoolTaskScheduler-");
    threadPoolTaskScheduler.setDaemon(true);
    return new TaskSchedulerWrapper(threadPoolTaskScheduler);
}

See More Examples