Java多线程：使用不同的线程创建新映射

我使用多线程已经有一段时间了。我需要以下场景的帮助。我有一份物品清单。我想为列表中的每一项执行一个方法，并将列表中每一项的不同结果存储在一个映射中，其中key是项，value是结果

public class RecordData {
    public static void main(String[] args) throws InterruptedException {
        List<String> names = new ArrayList<>();
        names.add("Krish");
        names.add("harry");
        names.add("Rin");

        DataGenerator generator = new DataGenerator(
                Executors.newFixedThreadPool(3));

        names.forEach(t -> generator.start(t));
        Thread.sleep(Duration.ofSeconds(2).toMillis());

        generator.stop();
        ConcurrentHashMap<String, DataGenerator.Result> resultMap = generator.getResultMap();
        System.out.println("resultMap");
    }
}


public class DataGenerator {

        private final ExecutorService executor;
        private final Random random;
        private List<String> request;
        private ConcurrentHashMap<UsageConsumed, Double> usageMap ;

    private ConcurrentHashMap<String, Result> resultMap= new ConcurrentHashMap<>();

        // Used to signal a graceful shutdown
        private volatile boolean stop = false;


        public DataGenerator(ExecutorService executor) {
            this.executor = executor;
            this.random = new Random();
        }

        public void start(String name) {
            Runnable generator = () -> {
                successfulRequest = new ArrayList<>();
                usageMap= new ConcurrentHashMap<>();
                usageMap.put(UsageConsumed.Write, 0.0);
                usageMap.put(UsageConsumed.Read, 0.0);
                try {
                    while (!stop) {
                        // my logic
                        //getData(status, productname, read, write);

                    }
                    Map<String, Long> successfulRequestLatencyMap;

                    synchronized(successfulRequest) {
                        successfulRequestLatencyMap = successfulRequest.stream().collect(Collectors.
                                groupingBy(e -> e, Collectors.counting()));
                    }


                   Result result = new Result(usageMap,
                            successfulRequestLatencyMap);

                    resultMap.put(name, result);
                } catch (Exception e) {
                    throw e;
                }
            };
            executor.execute(generator);
        }

        public void stop() {
            // Signal our thread to stop
            stop = true;

            // The shutdown the executor (after waiting a bit to be nice)
            try {
                executor.awaitTermination(1000, TimeUnit.MILLISECONDS);
            } catch (InterruptedException e) {
                // Purposely ignore any InterruptedException
                Thread.currentThread().interrupt();
            }
            executor.shutdownNow();
        }

        private void getData(int status, String productname, Double read,
                                           Double write) {
            if (status == 200) {
                request.add(productname);
            }
            usageMap.put(UsageConsumed.Read, usageMap.get(UsageConsumed.Read)+ read);
            usageMap.put(UsageConsumed.Write, usageMap.get(UsageConsumed.Write)+ write);
        }


    public ConcurrentHashMap<String, Result> getResultMap() {
        return resultMap;
    }



    public enum UsageConsumed {
        Read,
        Write
    }


    public class Result {
        private ConcurrentHashMap<UsageConsumed, Double> usageMap;
        private Map<String, Long> successfulRequestMap;
        public Result(ConcurrentHashMap<UsageConsumed, Double> usageMap,
                      Map<String, Long> RequestMap) {
            this.usageMap = usageMap;
            this.successfulRequestMap = RequestMap;
        }
    }

}

公共类记录数据{
公共静态void main（字符串[]args）引发InterruptedException{
列表名称=新的ArrayList（）；
名称。添加（“Krish”）；
姓名。添加（“哈里”）；
名称。添加（“Rin”）；
DataGenerator=新的DataGenerator(
Executors.newFixedThreadPool（3））；
name.forEach（t->generator.start（t））；
Thread.sleep（持续时间秒（2.toMillis（））；
发电机停止（）；
ConcurrentHashMap resultMap=generator.getResultMap（）；
System.out.println（“结果映射”）；
}
}
公共类数据生成器{
私人最终执行人服务执行人；
私有最终随机；
私人名单请求；
私有ConcurrentHashMapUsageMap；
私有ConcurrentHashMap resultMap=新ConcurrentHashMap（）；
//用于发出正常关机的信号
私有易失性布尔停止=false；
公共数据生成器（执行器服务执行器）{
this.executor=执行人；
this.random=新的random（）；
}
公共无效开始（字符串名称）{
可运行生成器=（）->{
successfulRequest=新建ArrayList（）；
usageMap=新的ConcurrentHashMap（）；
usageMap.put（usageconsumered.Write，0.0）；
usageMap.put（UsageConsumed.Read，0.0）；
试一试{
当（！停止）{
//我的逻辑
//getData（状态、产品名称、读取、写入）；
}
映射成功请求延迟映射；
已同步（成功请求）{
successfulRequestLatencyMap=successfulRequest.stream（）.collect（收集器）。
分组方式（e->e，Collectors.counting（））；
}
结果=新结果（usageMap，
成功请求延迟映射）；
结果映射put（名称、结果）；
}捕获（例外e）{
投掷e；
}
};
执行器。执行器（生成器）；
}
公共停车场（）{
//发信号让我们的线程停止
停止=真；
//关闭执行器（在等待一段时间之后）
试一试{
执行器等待终止（1000，时间单位毫秒）；
}捕捉（中断异常e）{
//故意忽略任何中断异常
Thread.currentThread（）.interrupt（）；
}
执行者。关机现在（）；
}
私有void getData（int状态、字符串productname、双读、，
双写）{
如果（状态==200）{
请求。添加（productname）；
}
usageMap.put（UsageConsumed.Read，usageMap.get（UsageConsumed.Read）+Read）；
usageMap.put（UsageConsumed.Write，usageMap.get（UsageConsumed.Write）+Write）；
}
公共ConcurrentHashMap getResultMap（）{
返回结果图；
}
公共枚举用法{
阅读
写
}
公开课成绩{
私有ConcurrentHashMapUsageMap；
私有映射成功请求映射；
公共结果（ConcurrentHashMap usageMap，
映射请求（映射）{
this.usageMap=usageMap；
this.successfulRequestMap=RequestMap；
}
}
}

---

我遇到了一个问题：对于列表中的每个项目，usageMap和successfulRequestMap的结果都是相同的，尽管值应该不同。我用上述代码得到的结果是所有三个项目的组合结果。需要帮助如何获得正确的结果。

您必须在

start（）

中设置

usageMap

本地，并将其作为参数传递给

getData（）

您的问题到底是什么？请记住，“我的代码不工作，请帮助”不是这里允许的问题。