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;
         }
     }
 }

由于任务是放在队列，在内存里面，所以应用重启会导致任务丢失，如果对于严格要求轮询查询的不合适用这种方式