定义一个ThreadPoolExecutor

private final BlockingQueue<Runnable> taskQueue = new LinkedBlockingDeque<>();
private final ThreadPoolExecutor executor = new ThreadPoolExecutor(10,
            10,
            0,
            TimeUnit.SECONDS,
            taskQueue);

需要的参数可以按照自己的需求进行配置
然后我们来创建一个新的线程类，

private class DemoTask implements Runnable{

        private List<String> x;
        private Object y;
        private Long z;

        private ScanTask(List<String> x,
                         Object y,
                         Long z){
            this.x = x;
            this.y = y;
            this.z = z;
        }


        private synchronized boolean checkCache(){
            if (onCache.contains(z)){
                return true;
            }
            return false;
        }

        @Override
        public void run() {
      if(checkCache){
        return;
      }  
      ...
    }
  }

使用的时候，只需要：

executor.execute(new DemoTask(x, y, z));

这样就使用了线程池。同时，如果需要做一个缓存来控制多线程情况下只有一个线程执行了某个操作，可以使用

private ConcurrentSkipListSet<Long> onCache = new ConcurrentSkipListSet<>();

在使用contain方法的时候，需要加线程同步