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;

         }

     }

 }

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

巴特西

ScheduledExecutorService调度线程池运行几次后停止某一个线程

最新文章

热门文章