ScheduledExecutorService調度線程池運行幾次后停止某一個線程

開發中偶爾會碰到一些輪詢需求，比如我碰到的和銀行對接，在做完某一個業務后銀行沒有同步給到結果，這時候就需要查詢返回結果，我們的需求是5分鍾一次，查詢3次，3次過后如果沒有結果則T+1等銀行的文件，對於這種任務我們的要求是輪詢不是很嚴格，所以我采取調度線程池方式，如果有查詢任務，加入線程池，設置好執行次數及執行時間間隔，具體代碼如下：

import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.*;


public class LocalTest {

    private static final Logger log = LoggerFactory.getLogger(LocalTest.class);

    @Test
    public void test01() throws InterruptedException {
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);
        ConcurrentHashMap<String, Future> futureMap = new ConcurrentHashMap<>();

        JobTest jobTest1 = new JobTest("job1",futureMap);
        Future future1 = executorService.scheduleAtFixedRate(jobTest1,1, 5, TimeUnit.SECONDS);
        futureMap.put(jobTest1.getJobId(),future1);

        JobTest jobTest2 = new JobTest("job2",futureMap);
        Future future2 = executorService.scheduleAtFixedRate(jobTest2,1, 5, TimeUnit.SECONDS);
        futureMap.put(jobTest2.getJobId(),future2);

        Thread.sleep(1000L * 30);

        JobTest jobTest3 = new JobTest("job3",futureMap);
        Future future3 = executorService.scheduleAtFixedRate(jobTest3,1, 5, TimeUnit.SECONDS);
        futureMap.put(jobTest1.getJobId(),future3);

        JobTest jobTest4 = new JobTest("job4",futureMap);
        Future future4 = executorService.scheduleAtFixedRate(jobTest4,1, 5, TimeUnit.SECONDS);
        futureMap.put(jobTest4.getJobId(),future4);

        Thread.sleep(1000L * 300);
        executorService.shutdown();
    }

    @Test
    public void test02() {

    }

    class JobTest implements Runnable {

        private ConcurrentHashMap<String, Future> futureMap;
        private int count = 0;
        private String jobId;

        public JobTest(){

        }

        public JobTest(String jobId, ConcurrentHashMap<String, Future> futureMap) {
            super();
            this.jobId = jobId;
            this.futureMap = futureMap;
        }

        @Override
        public void run() {
            count++;
            log.info("{} count is {}", jobId, count);
            if (count > 2) {
                Future future = futureMap.remove(jobId);
                future.cancel(true);
                log.info("{} had cancel", jobId);
            }
        }

        public String getJobId() {
            return jobId;
        }

        public void setJobId(String jobId) {
            this.jobId = jobId;
        }

        public ConcurrentHashMap<String, Future> getFutureMap() {
            return futureMap;
        }

        public void setFutureMap(ConcurrentHashMap<String, Future> futureMap) {
            this.futureMap = futureMap;
        }
    }
}

由於任務是放在隊列，在內存里面，所以應用重啟會導致任務丟失，如果對於嚴格要求輪詢查詢的不合適用這種方式