Java多线程返回值

我有一个循环流程的代码，代码如下：

for (int z = 0; z < m_ID.length; z++) {
    expretdata = expret.Get_Expected_Return(sStartDate, sEndDate, m_ID[z], sBookName, nHistReturn,nMarketReturn, nCustomReturn);
    m_Alpha[z] = expretdata;
}

for（int z=0；z

Get\u Expected\u Return（）。因此，如果
M_ID.length
超过200，则需要一个小时才能完成任务

我想用多线程优化它。我试图保存返回值以映射静态全局变量，并使用键对其重新排序。因为我需要按
M_ID.length
的索引对数据进行排序

但是，当我尝试运行多线程时，有些线程返回value=NULL，看起来该线程没有运行该方法

多线程是正确的方法吗？或者给我一些优化它的建议。
您可以使用
CompletableFuture
并行执行此任务。这里有一个例子

// lets define a wrapper class which is responsible to put calculated data into the array-> 

private void longExecution(int index, DataType m_Alpah,  ... sStartDate, sEndDate, m_ID_index_z, sBookName, nHistReturn,nMarketReturn, nCustomReturn){
        m_Alpha[index] =  expret.Get_Expected_Return(sStartDate, sEndDate, m_ID_index_z, sBookName, nHistReturn,nMarketReturn, nCustomReturn);
}

// Now from your code:

...
CompletableFuture[] futures = new CompletableFuture[m_ID.length];
for (int z = 0; z < m_ID.length; z++) {
   CompletableFuture.supplyAsync(() ->
                    longExecution(z, m_Alpah, sStartDate, sEndDate, m_ID[z], sBookName, nHistReturn,nMarketReturn, nCustomReturn));
);
}
// waiting for completing all of the futures.
CompletableFuture.allOf(futures).join();


// After this line:
//m_Alpha <- array will hold the result.


//让我们定义一个包装类，负责将计算出的数据放入数组->
私有void longExecution（int索引、数据类型m_Alpah、…sStartDate、sEndDate、m_ID_index_z、sBookName、nHistReturn、nMarketReturn、nCustomReturn）{
m_Alpha[index]=expret.Get_预期返回（sStartDate、sEndDate、m_ID_index_z、sBookName、nHistReturn、nMarketReturn、nCustomReturn）；
}
//现在从您的代码：
...
CompletableFuture[]futures=新的CompletableFuture[m_ID.length]；
对于（intz=0；z
长执行（z、m_Alpah、sStartDate、sEndDate、m_ID[z]、sBookName、nHistReturn、nMarketReturn、nCustomReturn）；
);
}
//等待完成所有的未来。
CompletableFuture.allOf（futures.join（）；
//在这一行之后：
//如果您昂贵的方法是独立的，并且不使用太多共享单一资源（如单个硬盘），那么多线程可能非常有用

您的有序结果用例可以使用Callables和Futures解决：

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;


class Test
{       
    static final int CALLS = 10;

    static int slowMethod(int n) throws InterruptedException
    {
        Thread.sleep(1000);
        return n+1;
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException
    {
        ExecutorService executor = Executors.newCachedThreadPool();
        List<Future<Integer>> futures = new ArrayList<>();

        for (int i = 0; i < CALLS ; i++)
        {
            final int finali = i;
            futures.add(executor.submit(()->slowMethod(finali)));               
        }
        for(Future<Integer> f: futures) {System.out.print(f.get());}
        executor.shutdown();
    }
}

import java.util.ArrayList；
导入java.util.List；
导入java.util.concurrent.ExecutionException；
导入java.util.concurrent.ExecutorService；
导入java.util.concurrent.Executors；
导入java.util.concurrent.Future；
课堂测试
{       
静态最终整数调用=10；
静态int slowMethod（int n）抛出中断异常
{
睡眠（1000）；
返回n+1；
}
公共静态void main（字符串[]args）引发InterruptedException、ExecutionException
{
ExecutorService executor=Executors.newCachedThreadPool（）；
列表期货=新的ArrayList（）；
for（int i=0；islowMethod（finali））；
}
for（Future f:futures）{System.out.print（f.get（））；}
executor.shutdown（）；
}
}
如果您使用的是Java 8或更高版本，则可以使用parallelStream

    m_Alpha = m_ID.parallelStream()
                 .map( z => {
                        return expret.Get_Expected_Return(sStartDate, sEndDate, m_ID[z], 
                                           sBookName, nHistReturn,nMarketReturn, nCustomReturn);
                  })
                 .toArray(Integer[]::new);


提供给Array方法的构造函数类型应该与m_Alpha的类型相同。
直接产生线程，然后使用
join
并收集结果，生成
ConcurrentHashMap
这里的问题是多个线程之间的通信很复杂，并且需要正确地同步，因为否则不同的线程可能会看到不同的数据/无数据/错误初始化的对象等。并发性和并行性是您需要研究的主题（），它的范围是waaay而不是SO答案。您可以尝试使用
ConcurrentHashMap
而不是
HashMap
，但很可能很快您也会在其他地方遇到其他问题。这里没有
返回。发布
返回的代码
，我们可能会有一些值得回答的问题。没有，没有。