线程池多线程等所有线程都执行完及callable的使用【我补充】
方法一：
作者：木女孩 链接：https://www.zhihu.com/question/52580874/answer/131132215 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 public class Test1 { public static ExecutorService executorService = Executors.newCachedThreadPool(); private static CountDownLatch cdl = new CountDownLatch(10); private static final Random random = new Random(); public void test() { for (int i = 0; i < 10; i++) executorService.execute(new ThreadTest()); } public static void main(String[] args) { new Test1().test(); //插入数据完成后 执行修改操作 try { cdl.await(); } catch (InterruptedException e) { } System.out.println("它们已经插完啦.............................."); executorService.shutdown(); } class ThreadTest implements Runnable { public void run() { //执行插入数据操作 每次插入一条 // 模拟耗时 int time = random.nextInt(10000); try { Thread.sleep(time); } catch (InterruptedException e) { } System.out.println(Thread.currentThread().getName() + "执行完了，耗时：" + time / 1000 + "秒"); cdl.countDown(); } } }
一种是上面的回答用CountDownLatch
另外一种思路就是用Callable：
好处就是精确知道每个线程的任务执行结果。
方法二：
作者：匿名用户
链接：https://www.zhihu.com/question/52580874/answer/131135646
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
public class JavaTest { public static ExecutorService executorService = Executors.newCachedThreadPool(); public void test(){ Future<Boolean>[] futures=new Future[10]; for (int i = 0 ;i<10;i++) futures[i]=executorService.submit(new ThreadTest()); for (int i = 0; i < 10; i++) { try { boolean success= futures[i].get(); System.out.println(String.format(Locale.CHINA,"执行完毕，结果为%s",success)); } catch (InterruptedException|ExecutionException e) { e.printStackTrace(); } } } public static void main(String[] args) { new JavaTest().test(); System.out.println("执行其他任务"); executorService.shutdown(); } class ThreadTest implements Callable<Boolean>{ @Override public Boolean call() throws Exception { System.out.println("开始插入数据"); Thread.sleep(2000); return true; } } }
我的例子：
public void testDaysFor() throws Exception{ long l1 = System.currentTimeMillis(); ExecutorService executor = Executors.newFixedThreadPool(4); List<TradeStatistics> list = new ArrayList<>(); //计算总执行次数，为了创建创建Feature数组 int count = 0; for (int i = 5; i < 8 ; i++) { for (int j = 3; j < i-2; j++) { count++; } } log.info("预计总执行次数：{}",count);
//创建Feature数组 Future<TradeStatistics>[] futures=new Future[count]; //重新赋值0，开多线程执行业务 count = 0; for (int i = 5; i < 8 ; i++) { for (int j = 3; j < i-2; j++) { log.info("j:{},i:{}",j,i); // Future<TradeStatistics> future = executor.submit(new TaskThread(i, j));
//给数组赋值并开启多线程 futures[count] = executor.submit(new MyThread(i, j)); count++; } } //多线程都启动好了后，开始阻塞获取结果，转为主线程同步执行后面代码 for (int i = 0; i < count; i++) { //下面这个get方法会阻塞到每个feature对象对应的线程执行完 TradeStatistics tradeStatistics = futures[i].get(); //添加到集合 list.add(tradeStatistics); } //关闭线程池 executor.shutdown(); long l2 = System.currentTimeMillis(); log.info("一共获取到：{}个,耗时：{}秒",list.size(),(l2-l1)/1000); //打印统计信息 for (int i = 0; i < list.size(); i++) { TradeStatistics ts = list.get(i); Double successRate = ts.getSuccessRate(); Integer finalProfit = ts.getFinalProfit(); String desc = ts.getStrategy().getDesc(); Integer id = ts.getId(); Integer closeSum = ts.getCloseSum(); log.info("id:{},益:{},率:{},共:{}次，策:{}",id,finalProfit,successRate, closeSum,desc); } } //线程任务 class MyThread implements Callable<TradeStatistics>{ Integer i; Integer j; public MyThread(Integer i, Integer j){ this.i = i; this.j = j; } @Override public TradeStatistics call() throws Exception {
//自定义的返回对象 TradeStatistics ts = new TradeStatistics();
//因为逻辑 ts.setIsRemind(false); ts.setInitAccount(100000); //避免内存占用过大 ts.setAllPrices(null); return ts; } }
我的例子2：
//多线程查询32个省数据方法 Object test(){ //查询32个省编码 List<Map> provinceList = xxMapper.qryProvince(); //总成功失败量 Integer sumSuccess = 0; Integer sumFail = 0; //返回省份数据集合 //开启多线程执行32个省查询 // ExecutorService executor = Executors.newFixedThreadPool(8); ExecutorService executor = Executors.newCachedThreadPool(); //线程返回对象集合 Future<Map<String,Integer>>[] futures=new Future[provinceList.size()]; //循环启动多线程 for (int i = 0; i <provinceList.size(); i++) { Map provinceMap = provinceList.get(i); //启动线程 futures[i] = executor.submit(() -> { //这里面其实是callable方法里面是业务逻辑 Integer regionId = Integer.valueOf(provinceMap.get("regionId")+""); String regionName = String.valueOf(provinceMap.get("regionName")); HashMap tempMap = new HashMap<String,Integer>(); tempMap.put("regionName",regionName); //成功 Integer successCount = xxMapper.qrySuccessCount(regionId, yearMonth, xx, null); tempMap.put("successCount",successCount); //失败 Integer failCount = xxMapper.qryFailCount(regionId,yearMonth,xx,null); tempMap.put("failCount",failCount);
//返回值就是callable线程执行的返回结果 return tempMap; }); } //多线程都启动好了后，开始阻塞获取结果，然后转为主线程同步执行后面代码 ArrayList<Map> provinceMapList = new ArrayList<>(); for (int i = 0; i < provinceList.size(); i++) { //下面这个get方法会阻塞到每个feature对象对应的线程执行完 Map<String,Integer> map = futures[i].get();
//组装每个线程的返回值到返回对象 sumSuccess+=map.get("successCount"); sumFail+=map.get("failCount"); //准备返回 provinceMapList.add(map); } //关闭线程池 executor.shutdown(); //封装返回 HashMap rtnMap = new HashMap(); rtnMap.put("provinceList",provinceMapList); rtnMap.put("sumSuccessCount",sumSuccess); rtnMap.put("sumFailCount",sumFail); rtnMap.put("sumCount",sumSuccess+sumFail); return rtnMap; }
//准备返回
