场景：


学校组织15个学生去拨一颗萝卜，每3个学生一组，各组全部完成拨萝卜后，然后公布结果


使用多线程进行实现

package com;
import com.google.common.collect.Lists;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;
import java.util.concurrent.*;
/**
 * 需求，使用
 * 学校组织15个学生去拨一颗萝卜，每3个学生一组，各组全部完成拨萝卜后，公布结果
 * 
 */
public class TestThread {
    public static void main(String[] args) throws InterruptedException {
        List<ConcurrentHashMap> personList = new ArrayList<ConcurrentHashMap>();
        //模拟15个学生
        for (int i=1;i<=15;){
            ConcurrentHashMap person = new ConcurrentHashMap();
            person.put("姓名：","学生（"+(i++)+")");
            personList.add(person);
        }
        //每组人数（3人）
        int groupPersonSize = 3;
        //按照每三人一组进行分组
        List<List<ConcurrentHashMap>> partition = Lists.partition(personList, groupPersonSize);
        //组数（计算一共几组）
        int groups = partition.size();
        //创建线程池
        ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat("apxs-Thread -%d").build();
        ExecutorService singleThreadPool = new ThreadPoolExecutor(
                groups, Integer.MAX_VALUE,200L
                , TimeUnit.MILLISECONDS
                ,new LinkedBlockingQueue<>(1024)
                , namedThreadFactory
                , new ThreadPoolExecutor.AbortPolicy()
        );
        //使用线程安全的Vector，作为计数器。
        List dataCount = new Vector();
        //根据组数，启动线程
        long startTime=System.currentTimeMillis();
        for (int i = 0; i < groups; i++) {
            int finalI = i;
            singleThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    dataCount.add(1);
                    List<ConcurrentHashMap> dbSources = partition.get(finalI);
                    System.out.printf("我是第%d小组，组内学生包含：%s，用时%s秒完成拨萝卜\n",finalI+1,dbSources.toString(),((float)(System.currentTimeMillis()-startTime)/1000));
                }
            });
        }
        singleThreadPool.shutdown();
        System.out.println("===========公布结果，如下===========");
        System.out.printf("本次分为%s组，以完成%s组",groups,dataCount.size());
    }
}

 下面是错误的输出结果，如下：

使用Java ThreadFactory 线程池_线程池

 
 

输出结果并不是需求描述中“分组完成后，才公布结果”，原因分析如下：

因为线程没有结束，就“公布结果”了。

解决方案：

可以使用​​CountDownLatch​​允许一个或者多个线程去等待其他线程完成操作。

package com;
import com.google.common.collect.Lists;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;
import java.util.concurrent.*;
/**
 * 需求，使用
 * 学校组织15个学生去拨一颗萝卜，每3个学生一组，各组全部完成拨萝卜后，公布结果
 * 
 */
public class TestThread {
    public static void main(String[] args) throws InterruptedException {
        List<ConcurrentHashMap> personList = new ArrayList<ConcurrentHashMap>();
        //模拟15个学生
        for (int i=1;i<=15;){
            ConcurrentHashMap person = new ConcurrentHashMap();
            person.put("姓名：","学生（"+(i++)+")");
            personList.add(person);
        }
        //每组人数（3人）
        int groupPersonSize = 3;
        //按照每三人一组进行分组
        List<List<ConcurrentHashMap>> partition = Lists.partition(personList, groupPersonSize);
        //组数（计算一共几组）
        int groups = partition.size();
        //创建线程池
        ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat("apxs-Thread -%d").build();
        ExecutorService singleThreadPool = new ThreadPoolExecutor(
                groups, Integer.MAX_VALUE,200L
                , TimeUnit.MILLISECONDS
                ,new LinkedBlockingQueue<>(1024)
                , namedThreadFactory
                , new ThreadPoolExecutor.AbortPolicy()
        );
        //使用线程安全的Vector，作为计数器。
        List dataCount = new Vector();
        //使用CountDownLatch允许一个或者多个线程去等待其他线程完成操作。
        CountDownLatch latch = new CountDownLatch(groups);
        //根据组数，启动线程
        long startTime=System.currentTimeMillis();
        for (int i = 0; i < groups; i++) {
            int finalI = i;
            singleThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    dataCount.add(1);
                    List<ConcurrentHashMap> dbSources = partition.get(finalI);
                    System.out.printf("我是第%d小组，组内学生包含：%s，用时%s秒完成拨萝卜\n",finalI+1,dbSources.toString(),((float)(System.currentTimeMillis()-startTime)/1000));
                    //使latch的值减1，如果减到了0，则会唤醒所有等待在这个latch上的线程。
                    latch.countDown();
                }
            });
        }
        //使当前线程进入同步队列进行等待，直到latch的值被减到0或者当前线程被中断，当前线程就会被唤醒。
        latch.await();
        singleThreadPool.shutdown();
        System.out.println("===========公布结果，如下===========");
        System.out.printf("本次分为%s组，以完成%s组",groups,dataCount.size());
    }
}

下面是正确的输出结果：

使用Java ThreadFactory 线程池_java_02