private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));// 这里 COUNT_BITS 设置为 29(32-3)，意味着前三位用于存放线程状态，后29位用于存放线程数// 很多初学者很喜欢在自己的代码中写很多 29 这种数字，或者某个特殊的字符串，然后分布在各个地方，这是非常糟糕的private static final int COUNT_BITS = Integer.SIZE - 3;// 000 11111111111111111111111111111// 这里得到的是 29 个 1，也就是说线程池的最大线程数是 2^29-1=536870911// 以我们现在计算机的实际情况，这个数量还是够用的private static final int CAPACITY   = (1 << COUNT_BITS) - 1;// 我们说了，线程池的状态存放在高 3 位中// 运算结果为 111跟29个0：111 00000000000000000000000000000private static final int RUNNING    = -1 << COUNT_BITS;// 000 00000000000000000000000000000private static final int SHUTDOWN   =  0 << COUNT_BITS;// 001 00000000000000000000000000000private static final int STOP       =  1 << COUNT_BITS;// 010 00000000000000000000000000000private static final int TIDYING    =  2 << COUNT_BITS;// 011 00000000000000000000000000000private static final int TERMINATED =  3 << COUNT_BITS;// 将整数 c 的低 29 位修改为 0，就得到了线程池的状态private static int runStateOf(int c)     { return c & ~CAPACITY; }// 将整数 c 的高 3 为修改为 0，就得到了线程池中的线程数private static int workerCountOf(int c)  { return c & CAPACITY; }private static int ctlOf(int rs, int wc) { return rs | wc; }private static boolean runStateLessThan(int c, int s) {return c < s;}private static boolean runStateAtLeast(int c, int s) {return c >= s;}private static boolean isRunning(int c) {return c < SHUTDOWN;}

    public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,long keepAliveTime, TimeUnit unit,BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory,RejectedExecutionHandler handler) {if (corePoolSize < 0 || maximumPoolSize <= 0|| maximumPoolSize < corePoolSize || keepAliveTime < 0)throw new IllegalArgumentException();if (workQueue == null || threadFactory == null || handler == null)throw new NullPointerException();this.corePoolSize = corePoolSize;this.maximumPoolSize = maximumPoolSize;this.workQueue = workQueue;this.keepAliveTime = unit.toNanos(keepAliveTime);this.threadFactory = threadFactory;this.handler = handler;}

    public static ExecutorService newFixedThreadPool(int nThreads) {return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>());}

public static ExecutorService newSingleThreadExecutor() {return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>()));}

  public static ExecutorService newCachedThreadPool() {return new ThreadPoolExecutor(0, Integer.MAX_VALUE,60L, TimeUnit.SECONDS,new SynchronousQueue<Runnable>());}

public void execute(Runnable command) {if (command == null)throw new NullPointerException();// 前面说的那个表示 “线程池状态” 和 “线程数” 的整数int c = ctl.get();// 如果当前线程数少于核心线程数，那么直接添加一个 worker 来执行任务，// 创建一个新的线程，并把当前任务 command 作为这个线程的第一个任务(firstTask)if (workerCountOf(c) < corePoolSize) {// 添加任务成功，那么就结束了。提交任务嘛，线程池已经接受了这个任务，这个方法也就可以返回了// 至于执行的结果，到时候会包装到 FutureTask 中。// 返回 false 代表线程池不允许提交任务if (addWorker(command, true))return;c = ctl.get();}// 到这里说明，要么当前线程数大于等于核心线程数，要么刚刚 addWorker 失败了// 如果线程池处于 RUNNING 状态，把这个任务添加到任务队列 workQueue 中if (isRunning(c) && workQueue.offer(command)) {/* 这里面说的是，如果任务进入了 workQueue，我们是否需要开启新的线程* 因为线程数在 [0, corePoolSize) 是无条件开启新的线程* 如果线程数已经大于等于 corePoolSize，那么将任务添加到队列中，然后进到这里*/int recheck = ctl.get();// 如果线程池已不处于 RUNNING 状态，那么移除已经入队的这个任务，并且执行拒绝策略if (! isRunning(recheck) && remove(command))reject(command);// 如果线程池还是 RUNNING 的，并且线程数为 0，那么开启新的线程// 到这里，我们知道了，这块代码的真正意图是：担心任务提交到队列中了，但是线程都关闭了else if (workerCountOf(recheck) == 0)addWorker(null, false);}// 如果 workQueue 队列满了，那么进入到这个分支// 以 maximumPoolSize 为界创建新的 worker，// 如果失败，说明当前线程数已经达到 maximumPoolSize，执行拒绝策略else if (!addWorker(command, false))reject(command);
}

// 第一个参数是准备提交给这个线程执行的任务，之前说了，可以为 null
// 第二个参数为 true 代表使用核心线程数 corePoolSize 作为创建线程的界线，也就说创建这个线程的时候，
//         如果线程池中的线程总数已经达到 corePoolSize，那么不能响应这次创建线程的请求
//         如果是 false，代表使用最大线程数 maximumPoolSize 作为界线
private boolean addWorker(Runnable firstTask, boolean core) {retry:for (;;) {int c = ctl.get();int rs = runStateOf(c);// 这个非常不好理解// 如果线程池已关闭，并满足以下条件之一，那么不创建新的 worker：// 1. 线程池状态大于 SHUTDOWN，其实也就是 STOP, TIDYING, 或 TERMINATED// 2. firstTask != null// 3. workQueue.isEmpty()// 简单分析下：// 还是状态控制的问题，当线程池处于 SHUTDOWN 的时候，不允许提交任务，但是已有的任务继续执行// 当状态大于 SHUTDOWN 时，不允许提交任务，且中断正在执行的任务// 多说一句：如果线程池处于 SHUTDOWN，但是 firstTask 为 null，且 workQueue 非空，那么是允许创建 worker 的if (rs >= SHUTDOWN &&! (rs == SHUTDOWN &&firstTask == null &&! workQueue.isEmpty()))return false;for (;;) {int wc = workerCountOf(c);if (wc >= CAPACITY ||wc >= (core ? corePoolSize : maximumPoolSize))return false;// 如果成功，那么就是所有创建线程前的条件校验都满足了，准备创建线程执行任务了// 这里失败的话，说明有其他线程也在尝试往线程池中创建线程if (compareAndIncrementWorkerCount(c))break retry;// 由于有并发，重新再读取一下 ctlc = ctl.get();// 正常如果是 CAS 失败的话，进到下一个里层的for循环就可以了// 可是如果是因为其他线程的操作，导致线程池的状态发生了变更，如有其他线程关闭了这个线程池// 那么需要回到外层的for循环if (runStateOf(c) != rs)continue retry;// else CAS failed due to workerCount change; retry inner loop
        }}/* * 到这里，我们认为在当前这个时刻，可以开始创建线程来执行任务了，* 因为该校验的都校验了，至于以后会发生什么，那是以后的事，至少当前是满足条件的*/// worker 是否已经启动boolean workerStarted = false;// 是否已将这个 worker 添加到 workers 这个 HashSet 中boolean workerAdded = false;Worker w = null;try {final ReentrantLock mainLock = this.mainLock;// 把 firstTask 传给 worker 的构造方法w = new Worker(firstTask);// 取 worker 中的线程对象，之前说了，Worker的构造方法会调用 ThreadFactory 来创建一个新的线程final Thread t = w.thread;if (t != null) {// 这个是整个类的全局锁，持有这个锁才能让下面的操作“顺理成章”，// 因为关闭一个线程池需要这个锁，至少我持有锁的期间，线程池不会被关闭
            mainLock.lock();try {int c = ctl.get();int rs = runStateOf(c);// 小于 SHUTTDOWN 那就是 RUNNING，这个自不必说，是最正常的情况// 如果等于 SHUTDOWN，前面说了，不接受新的任务，但是会继续执行等待队列中的任务if (rs < SHUTDOWN ||(rs == SHUTDOWN && firstTask == null)) {// worker 里面的 thread 可不能是已经启动的if (t.isAlive())throw new IllegalThreadStateException();// 加到 workers 这个 HashSet 中
                    workers.add(w);int s = workers.size();// largestPoolSize 用于记录 workers 中的个数的最大值// 因为 workers 是不断增加减少的，通过这个值可以知道线程池的大小曾经达到的最大值if (s > largestPoolSize)largestPoolSize = s;workerAdded = true;}} finally {mainLock.unlock();}// 添加成功的话，启动这个线程if (workerAdded) {// 启动线程
                t.start();workerStarted = true;}}} finally {// 如果线程没有启动，需要做一些清理工作，如前面 workCount 加了 1，将其减掉if (! workerStarted)addWorkerFailed(w);}// 返回线程是否启动成功return workerStarted;

    private final class Worker extends AbstractQueuedSynchronizerimplements Runnable {private static final long serialVersionUID = 6138294804551838833L;// task 的threadfinal Thread thread;// 运行的任务task
        Runnable firstTask;volatile long completedTasks;Worker(Runnable firstTask) {//设置AQS的同步状态private volatile int state，是一个计数器，大于0代表锁已经被获取setState(-1);this.firstTask = firstTask;// 利用ThreadFactory和 Worker这个Runnable创建的线程对象this.thread = getThreadFactory().newThread(this);}// 任务执行public void run() {runWorker(this);}}

// 此方法由 worker 线程启动后调用，这里用一个 while 循环来不断地从等待队列中获取任务并执行
// 前面说了，worker 在初始化的时候，可以指定 firstTask，那么第一个任务也就可以不需要从队列中获取
final void runWorker(Worker w) {// Thread wt = Thread.currentThread();// 该线程的第一个任务(如果有的话)Runnable task = w.firstTask;w.firstTask = null;w.unlock(); // allow interruptsboolean completedAbruptly = true;try {// 循环调用 getTask 获取任务while (task != null || (task = getTask()) != null) {w.lock();          // 如果线程池状态大于等于 STOP，那么意味着该线程也要中断if ((runStateAtLeast(ctl.get(), STOP) ||(Thread.interrupted() &&runStateAtLeast(ctl.get(), STOP))) &&!wt.isInterrupted())wt.interrupt();try {// 这是一个钩子方法，留给需要的子类实现
                beforeExecute(wt, task);Throwable thrown = null;try {// 到这里终于可以执行任务了
                    task.run();} catch (RuntimeException x) {thrown = x; throw x;} catch (Error x) {thrown = x; throw x;} catch (Throwable x) {// 这里不允许抛出 Throwable，所以转换为 Errorthrown = x; throw new Error(x);} finally {// 也是一个钩子方法，将 task 和异常作为参数，留给需要的子类实现
                    afterExecute(task, thrown);}} finally {// 置空 task，准备 getTask 获取下一个任务task = null;// 累加完成的任务数w.completedTasks++;// 释放掉 worker 的独占锁
                w.unlock();}}completedAbruptly = false;} finally {// 如果到这里，需要执行线程关闭：// 1. 说明 getTask 返回 null，也就是说，这个 worker 的使命结束了，执行关闭// 2. 任务执行过程中发生了异常// 第一种情况，已经在代码处理了将 workCount 减 1，这个在 getTask 方法分析中会说// 第二种情况，workCount 没有进行处理，所以需要在 processWorkerExit 中处理// 限于篇幅，我不准备分析这个方法了，感兴趣的读者请自行分析源码
        processWorkerExit(w, completedAbruptly);}
}

// 此方法有三种可能：
// 1. 阻塞直到获取到任务返回。我们知道，默认 corePoolSize 之内的线程是不会被回收的，
//      它们会一直等待任务
// 2. 超时退出。keepAliveTime 起作用的时候，也就是如果这么多时间内都没有任务，那么应该执行关闭
// 3. 如果发生了以下条件，此方法必须返回 null:
//    - 池中有大于 maximumPoolSize 个 workers 存在(通过调用 setMaximumPoolSize 进行设置)
//    - 线程池处于 SHUTDOWN，而且 workQueue 是空的，前面说了，这种不再接受新的任务
//    - 线程池处于 STOP，不仅不接受新的线程，连 workQueue 中的线程也不再执行
private Runnable getTask() {boolean timedOut = false; // Did the last poll() time out?
retry:for (;;) {int c = ctl.get();int rs = runStateOf(c);// 两种可能// 1. rs == SHUTDOWN && workQueue.isEmpty()// 2. rs >= STOPif (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {// CAS 操作，减少工作线程数
            decrementWorkerCount();return null;}boolean timed;      // Are workers subject to culling?for (;;) {int wc = workerCountOf(c);// 允许核心线程数内的线程回收，或当前线程数超过了核心线程数，那么有可能发生超时关闭timed = allowCoreThreadTimeOut || wc > corePoolSize;// 这里 break，是为了不往下执行后一个 if (compareAndDecrementWorkerCount(c))// 两个 if 一起看：如果当前线程数 wc > maximumPoolSize，或者超时，都返回 null// 那这里的问题来了，wc > maximumPoolSize 的情况，为什么要返回 null？//    换句话说，返回 null 意味着关闭线程。// 那是因为有可能开发者调用了 setMaximumPoolSize 将线程池的 maximumPoolSize 调小了if (wc <= maximumPoolSize && ! (timedOut && timed))break;if (compareAndDecrementWorkerCount(c))return null;c = ctl.get();  // Re-read ctl// compareAndDecrementWorkerCount(c) 失败，线程池中的线程数发生了改变if (runStateOf(c) != rs)continue retry;// else CAS failed due to workerCount change; retry inner loop
        }// wc <= maximumPoolSize 同时没有超时try {// 到 workQueue 中获取任务Runnable r = timed ?workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :workQueue.take();if (r != null)return r;timedOut = true;} catch (InterruptedException retry) {// 如果此 worker 发生了中断，采取的方案是重试// 解释下为什么会发生中断，这个读者要去看 setMaximumPoolSize 方法，// 如果开发者将 maximumPoolSize 调小了，导致其小于当前的 workers 数量，// 那么意味着超出的部分线程要被关闭。重新进入 for 循环，自然会有部分线程会返回 nulltimedOut = false;}}
}

 private void processWorkerExit(Worker w, boolean completedAbruptly) {// true：用户线程运行异常,需要扣减// false：getTask方法中扣减线程数量if (completedAbruptly)decrementWorkerCount();// 获取主锁final ReentrantLock mainLock = this.mainLock;mainLock.lock();try {completedTaskCount += w.completedTasks;// 从HashSet中移出worker
            workers.remove(w);} finally {mainLock.unlock();}// 有worker线程移除，可能是最后一个线程退出需要尝试终止线程池
        tryTerminate();int c = ctl.get();// 如果线程为running或shutdown状态，即tryTerminate()没有成功终止线程池，则判断是否有必要一个workerif (runStateLessThan(c, STOP)) {// 正常退出，计算min：需要维护的最小线程数量if (!completedAbruptly) {// allowCoreThreadTimeOut 默认false：是否需要维持核心线程的数量int min = allowCoreThreadTimeOut ? 0 : corePoolSize;// 如果min ==0 或者workerQueue为空，min = 1if (min == 0 && ! workQueue.isEmpty())min = 1;// 如果线程数量大于最少数量min，直接返回，不需要新增线程if (workerCountOf(c) >= min)return; // replacement not needed
            }// 添加一个没有firstTask的workeraddWorker(null, false);}}

  final void tryTerminate() {for (;;) {int c = ctl.get();// 线程池处于Running状态// 线程池已经终止了// 线程池处于ShutDown状态，但是阻塞队列不为空if (isRunning(c) ||runStateAtLeast(c, TIDYING) ||(runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))return;// 执行到这里，就意味着线程池要么处于STOP状态，要么处于SHUTDOWN且阻塞队列为空// 这时如果线程池中还存在线程，则会尝试中断线程if (workerCountOf(c) != 0) {// /线程池还有线程，但是队列没有任务了，需要中断唤醒等待任务的线程// （runwoker的时候首先就通过w.unlock设置线程可中断，getTask最后面的catch处理中断）
                interruptIdleWorkers(ONLY_ONE);return;}final ReentrantLock mainLock = this.mainLock;mainLock.lock();try {// 尝试终止线程池if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {try {terminated();} finally {// 线程池状态转为TERMINATEDctl.set(ctlOf(TERMINATED, 0));termination.signalAll();}return;}} finally {mainLock.unlock();}}}

 public void shutdown() {final ReentrantLock mainLock = this.mainLock;mainLock.lock();try {checkShutdownAccess();// 推进线程状态
            advanceRunState(SHUTDOWN);// 中断空闲的线程
            interruptIdleWorkers();// 交给子类实现
            onShutdown();} finally {mainLock.unlock();}tryTerminate();}

public List<Runnable> shutdownNow() {List<Runnable> tasks;final ReentrantLock mainLock = this.mainLock;mainLock.lock();try {checkShutdownAccess();advanceRunState(STOP);// 中断所有线程
            interruptWorkers();// 返回等待执行的任务列表tasks = drainQueue();} finally {mainLock.unlock();}tryTerminate();return tasks;}

private void interruptWorkers() {final ReentrantLock mainLock = this.mainLock;mainLock.lock();try {for (Worker w : workers)w.interruptIfStarted();} finally {mainLock.unlock();}}

    private List<Runnable> drainQueue() {BlockingQueue<Runnable> q = workQueue;ArrayList<Runnable> taskList = new ArrayList<Runnable>();q.drainTo(taskList);if (!q.isEmpty()) {for (Runnable r : q.toArray(new Runnable[0])) {if (q.remove(r))taskList.add(r);}}return taskList;}

final void reject(Runnable command) {// 执行拒绝策略handler.rejectedExecution(command, this);
}// 只要线程池没有被关闭，那么由提交任务的线程自己来执行这个任务。
public static class CallerRunsPolicy implements RejectedExecutionHandler {public CallerRunsPolicy() { }public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {if (!e.isShutdown()) {r.run();}}
}// 不管怎样，直接抛出 RejectedExecutionException 异常
// 这个是默认的策略，如果我们构造线程池的时候不传相应的 handler 的话，那就会指定使用这个
public static class AbortPolicy implements RejectedExecutionHandler {public AbortPolicy() { }public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {throw new RejectedExecutionException("Task " + r.toString() +" rejected from " +e.toString());}
}// 不做任何处理，直接忽略掉这个任务
public static class DiscardPolicy implements RejectedExecutionHandler {public DiscardPolicy() { }public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {}
}// 这个相对霸道一点，如果线程池没有被关闭的话，
// 把队列队头的任务(也就是等待了最长时间的)直接扔掉，然后提交这个任务到等待队列中
public static class DiscardOldestPolicy implements RejectedExecutionHandler {public DiscardOldestPolicy() { }public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {if (!e.isShutdown()) {e.getQueue().poll();e.execute(r);}}
}

class Test {public static void main(String[] args) {ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 200,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(5));for (int i = 0; i < 15; i++) {MyTask myTask = new MyTask(i);executor.execute(myTask);System.out.println("线程池中线程数目：" + executor.getPoolSize()+ "，队列中等待执行的任务数目：" + executor.getQueue().size()+ "，已执行玩别的任务数目：" + executor.getCompletedTaskCount());}executor.shutdown();}
}class MyTask implements Runnable {private int taskNum;public MyTask(int num) {this.taskNum = num;}@Overridepublic void run() {System.out.println("正在执行task " + taskNum);try {Thread.currentThread().sleep(4000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("task " + taskNum + "执行完毕");}
}

正在执行task 0
线程池中线程数目：1，队列中等待执行的任务数目：0，已执行玩别的任务数目：0
线程池中线程数目：2，队列中等待执行的任务数目：0，已执行玩别的任务数目：0
正在执行task 1
正在执行task 2
线程池中线程数目：3，队列中等待执行的任务数目：0，已执行玩别的任务数目：0
线程池中线程数目：4，队列中等待执行的任务数目：0，已执行玩别的任务数目：0
正在执行task 3
线程池中线程数目：5，队列中等待执行的任务数目：0，已执行玩别的任务数目：0
正在执行task 4
线程池中线程数目：5，队列中等待执行的任务数目：1，已执行玩别的任务数目：0
线程池中线程数目：5，队列中等待执行的任务数目：2，已执行玩别的任务数目：0
线程池中线程数目：5，队列中等待执行的任务数目：3，已执行玩别的任务数目：0
线程池中线程数目：5，队列中等待执行的任务数目：4，已执行玩别的任务数目：0
线程池中线程数目：5，队列中等待执行的任务数目：5，已执行玩别的任务数目：0
线程池中线程数目：6，队列中等待执行的任务数目：5，已执行玩别的任务数目：0
正在执行task 10
线程池中线程数目：7，队列中等待执行的任务数目：5，已执行玩别的任务数目：0
正在执行task 11
线程池中线程数目：8，队列中等待执行的任务数目：5，已执行玩别的任务数目：0
正在执行task 12
线程池中线程数目：9，队列中等待执行的任务数目：5，已执行玩别的任务数目：0
正在执行task 13
线程池中线程数目：10，队列中等待执行的任务数目：5，已执行玩别的任务数目：0
正在执行task 14
task 0执行完毕
正在执行task 5
task 1执行完毕
task 2执行完毕
task 3执行完毕
task 4执行完毕
正在执行task 9
正在执行task 8
正在执行task 7
正在执行task 6
task 12执行完毕
task 13执行完毕
task 10执行完毕
task 11执行完毕
task 14执行完毕
task 5执行完毕
task 6执行完毕
task 7执行完毕
task 9执行完毕
task 8执行完毕

View Code

class GetMonitorDataService {private Logger logger = LoggerFactory.getLogger(GetMonitorDataService.class);@Resourceprivate MonitorProjectUrlMapper groupUrlMapper;@Resourceprivate MonitorDetailBatchInsertMapper monitorDetailBatchInsertMapper;public void sendData(){//调用dao查询所有urlMonitorProjectUrlExample example=new MonitorProjectUrlExample();List<MonitorProjectUrl> list=groupUrlMapper.selectByExample(example);logger.info("此次查询数据库中监控url个数为"+list.size());//获取系统处理器个数，作为线程池数量int nThreads=Runtime.getRuntime().availableProcessors();//定义一个装载多线程返回值的集合List<MonitorDetail> result= Collections.synchronizedList(new ArrayList<MonitorDetail>());//创建线程池，这里定义了一个创建线程池的工具类，避免了创建多个线程池，ThreadPoolFactoryUtil可以使用单例模式设计ExecutorService executorService = ThreadPoolFactoryUtil.getExecutorService(nThreads);//遍历数据库取出的urlif(list!=null&&list.size()>0) {for (MonitorProjectUrl monitorProjectUrl : list) {String url = monitorProjectUrl.getMonitorUrl();//创建任务ThreadTask threadTask = new ThreadTask(url, result);//执行任务
                executorService.execute(threadTask);try {//等待直到所有任务完成
                          executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.MINUTES);} catch (InterruptedException e) {e.printStackTrace();}}executorService.shutdown();//对数据进行操作
            saveData(result);}}
}public class ThreadTask implements Runnable{//这里实现runnable接口private String url;private List<MonitorDetail> list;public ThreadTask(String url,List<MonitorDetail> list){this.url=url;this.list=list;}//把获取的数据进行处理
    @Overridepublic void run() {MonitorDetail detail = HttpClientUtil.send(url, MonitorDetail.class);list.add(detail);}}

public class FatureTest {//1、配置线程池private static ExecutorService es = Executors.newFixedThreadPool(20);//2、封装响应Featureclass BizResult{public String orderId;public String  data;public String getOrderId() {return orderId;}public void setOrderId(String orderId) {this.orderId = orderId;}public String getData() {return data;}public void setData(String data) {this.data = data;}}//3、实现Callable接口class BizTask implements Callable {private String orderId;private Object data;//可以用其他方式private CountDownLatch countDownLatch;public BizTask(String orderId, Object data, CountDownLatch countDownLatch) {this.orderId = orderId;this.data = data;this.countDownLatch = countDownLatch;}@Overridepublic Object call() {try {//todo businessSystem.out.println("当前线程Id = " + this.orderId);BizResult br = new BizResult();br.setOrderId(this.orderId);br.setData("some key about your business" + this.getClass());return br;}catch (Exception e){e.printStackTrace();}finally {//线程结束时，将计时器减一
                countDownLatch.countDown();}return null;}}/*** 业务逻辑入口*/public List<Future> beginBusiness() throws InterruptedException {//模拟批量业务数据List<String> list = new ArrayList<>();for (int i = 0 ; i < 1000 ; i++) {list.add(String.valueOf(i));}//设置计数器CountDownLatch countDownLatch = new CountDownLatch(list.size());//接收多线程响应结果List<Future> resultList = new ArrayList<>();//begin threadfor( int i = 0 ,size = list.size() ; i<size; i++){//todo something befor threadresultList.add(es.submit(new BizTask(list.get(i), null, countDownLatch)));}//wait finish
        countDownLatch.await();return resultList;}public static void main(String[] args) throws InterruptedException {FatureTest ft = new FatureTest();List<Future> futures = ft.beginBusiness();System.out.println("futures.size() = " + futures.size());//todo some operateSystem.out.println(" ==========================end========================= " );}}