ExecuteRun

package main.com.lift;

import com.google.common.collect.Lists;
import com.google.common.collect.Maps;

import java.lang.annotation.Target;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.concurrent.*;

public class ExecuteRun {
    public double runanswer(List> produceElem, LinkedBlockingQueue queue)throws  Exception{
        CyclicBarrier cyclicBarrier=new CyclicBarrier(produceElem.size());
        List threads= Lists.newArrayList();
        Map futureTaskMap= Maps.newHashMap();
        for(int i=0;i futureTaskMap2=Maps.newHashMap();
        for(int i=0;i waitqueue=(Queue) futureTaskMap.get("lift"+i).get();
            Task2 task2=new Task2(waitqueue);
            FutureTask futureTask=new FutureTask<>(task2);
            Thread childThread=new Thread(futureTask,"lift"+i);
            futureTaskMap2.put("lift"+i,futureTask);
            childThread.start();
        }
        //存放所有电梯的运行时间
        Map sumTime=Maps.newHashMap();

        //**********************************************不开启监控***************************************************
//        for(Map.Entry entry:futureTaskMap2.entrySet()){
//            String item2=entry.getKey();
//            FutureTask intlift=entry.getValue();
//            //如果自己的线程消费完了，区分担其他线程的
//            if(intlift.get()!=null){
//                try{
//                    sumTime.put(item2,(double)intlift.get());
//
//                }catch (Exception e){
//                    e.printStackTrace();
//                }
//            }
//        }
        //****************************************开启监控*******************************************
        //监控线程是否结束
        int mapsize=0;
        List allThread=Lists.newArrayList();
        List allCallable=Lists.newArrayList();
        do{
            for(Map.Entry entry:futureTaskMap2.entrySet()){
                String item2=entry.getKey();
                FutureTask intlift=entry.getValue();
                //如果自己的线程消费完了后，去分担其他线程的
                if(intlift.get()!=null){
                    mapsize++;
                    try{
                        sumTime.put(item2,(double)intlift.get());
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    Thread t=new Thread(new Runnable() {
                        @Override
                        public void run() {
                            //一个电梯运完自己队列里的人后，去其他的队列中去找有没有符合自己能到达楼层的人
                            List lift=produceElem.get(Integer.parseInt(item2.substring(4,item2.length())));
                            //存放新建的线程
                            Map futureTaskMapson=Maps.newHashMap();
                            futureTaskMap.forEach((item,intperson) ->{
                                try{
                                    Queue waitqueue2=(Queue) intperson.get();
                                    //检查遍历到的队列，如果有元素在可以消费的队列中，就加入消费，并删除
                                    synchronized (waitqueue2){
                                        if(!waitqueue2.isEmpty()){
                                            Queue waitqueuSon=Lists.newLinkedList();
                                            for(int x=0;x) waitqueue2).remove(x);
                                                    x--;
                                                }
                                                if(waitqueuSon.size()==5 || waitqueue2.size()==0){
                                                    break;
                                                }
                                            }
                                            if(waitqueuSon.size()<=0){
                                                return;
                                            }
                                            //取到后新启一个线程消费
                                            Task2 taskson=new Task2(waitqueuSon);
                                            FutureTask futureTask=new FutureTask<>(taskson);
                                            if(futureTaskMapson.get(item2) ==null){
                                                futureTaskMapson.put(item2,futureTask);
                                            }else {
                                                //否则就先拿到之前运行的时间，在放进去新的执行
                                                double itemson=(double)futureTaskMapson.get(item2).get();
                                                sumTime.put(item2,sumTime.get(item2)+itemson);
                                                futureTaskMapson.put(item2,futureTask);
                                            }
                                            allCallable.add(taskson);
                                            futureTask.run();
                                        }
                                    }
                                } catch (Exception e) {
                                    e.printStackTrace();
                                }
                            });
                            int mapsize2=0;
                            //所有运行完了之后就再次清算新建的自消费线程
                            do{
                                for(Map.Entry entry2:futureTaskMapson.entrySet()){
                                    String item2son=entry2.getKey();
                                    FutureTask intliftson=entry2.getValue();
                                    try{
                                        if(intliftson.get()!=null){
                                            mapsize2++;
                                            try{
                                                double itemson=(double)intliftson.get();
                                                if(sumTime.get(item2son)!=null){
                                                    sumTime.put(item2son,sumTime.get(item2son)+itemson);
                                                }
                                            }catch (Exception e){
                                                e.printStackTrace();
                                            }
                                        }
                                    }catch (Exception e){
                                        e.printStackTrace();
                                    }
                                }
                            }while (mapsize2{
            System.out.println(k+" : "+ v);
        });
        allThread.forEach(thread -> {
            try{
                thread.join();
            }catch (Exception e){
                e.printStackTrace();
            }
        });
        double maxtime=0;
        for(Map.Entry entry:sumTime.entrySet()){
            if(maxtime