Java 多线程执行时间最小化

下面是我的代码。我正在通过线程填充一个3500000大小的列表。首先，我用一个线程填充列表。这个线程将返回一个包含3500000项的字符串列表

执行此过程需要5秒钟

然后，我创建了另一个线程，并将整个任务分成两部分，然后将它们分发给线程

第一个线程将填充1900000个项目的字符串列表，第二个线程将返回（3500000-1900000=1600000）个项目。这两个进程并行运行。因此，测试应该花费更少的时间。 但是，对于这种情况，总计算时间也是5秒

请任何人帮我找出我做错了什么

我迫切需要将执行时间最小化。我怎样才能尽量减少时间

package callablefutures;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.Calendar;
import java.util.concurrent.TimeUnit;
import java.util.Date;

public class CallableFutures {

  private static final int NTHREDS = 10;
  public static void main(String[] args) {

  ExecutorService executor = Executors.newFixedThreadPool(NTHREDS);
  List<Future<List<String>>> list = new ArrayList<Future<List<String>>>();


    List<List<String>> lst=new ArrayList();
    List<String> list1=new ArrayList();
    List<String> list2=new ArrayList();


  Runtime rt = Runtime.getRuntime();
  long prevFree = rt.freeMemory();
  long startTime=System.currentTimeMillis();


      Callable<List<String>> worker = new MyCallable(list1,0,1900000);
      Future<List<String>> submit = executor.submit(worker);
      list.add(submit);

      Callable<List<String>> worker1 = new MyCallable(list2,1900000,3500000);
      Future<List<String>> submit1 = executor.submit(worker1);
      list.add(submit1);

    long sum = 0;
    System.out.println(list.size());

    for (Future<List<String>> future : list) {
      try {
          lst.add(future.get());
      } catch (InterruptedException e) {
        e.printStackTrace();
      } catch (ExecutionException e) {
        e.printStackTrace();
      }
    }
    executor.shutdown();
  long endTime=System.currentTimeMillis();
    System.out.println("Total Time Taken: " + (endTime-startTime)/1000%60 +" Seconds");
    System.out.println("Total Memory Taken (MB): " + ((prevFree-rt.freeMemory())/1024)/1024);
  }
}



package callablefutures;
import java.util.concurrent.Callable;
import java.util.List;
import java.util.ArrayList;

public class MyCallable implements Callable<List<String>>{
  public List<String> StrList=new ArrayList();
  public int sIndex,eIndex;
  public MyCallable(List<String> oList,int si,int ei)
  {
      this.StrList=oList;
      this.sIndex=si;
      this.eIndex=ei;
  }
  @Override
  public List<String> call() throws Exception {

    for (int i = this.sIndex; i < this.eIndex; i++) {
      this.StrList.add("ID  "+i);
    }
    return this.StrList;
    //return this.StrList;
  }

}

packagecallablefutures；
导入java.util.ArrayList；
导入java.util.List；
导入java.util.concurrent.Callable；
导入java.util.concurrent.ExecutionException；
导入java.util.concurrent.ExecutorService；
导入java.util.concurrent.Executors；
导入java.util.concurrent.Future；
导入java.util.Calendar；
导入java.util.concurrent.TimeUnit；
导入java.util.Date；
公共类可赎回期货{
专用静态最终int=10；
公共静态void main（字符串[]args）{
ExecutorService executor=Executors.newFixedThreadPool（n个红色）；
列表=新的ArrayList（）；
List lst=new ArrayList（）；
List list1=新的ArrayList（）；
List list2=新的ArrayList（）；
Runtime rt=Runtime.getRuntime（）；
long prevFree=rt.freemory（）；
long startTime=System.currentTimeMillis（）；
可调用工人=新的MyCallable（列表1,01900000）；
未来提交=执行人提交（工人）；
列表。添加（提交）；
Callable worker1=新的MyCallable（列表2190000035000）；
未来提交1=执行人提交（工作1）；
列表。添加（提交1）；
长和=0；
System.out.println（list.size（））；
用于（未来：列表）{
试一试{
lst.add（future.get（））；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}捕获（执行例外）{
e、 printStackTrace（）；
}
}
executor.shutdown（）；
long-endTime=System.currentTimeMillis（）；
System.out.println（“所用总时间：+（结束时间开始时间）/1000%60+“秒”）；
System.out.println（“占用的总内存（MB）：”+（（prevFree-rt.freemory（））/1024）/1024）；
}
}
一揽子可赎回期货；
导入java.util.concurrent.Callable；
导入java.util.List；
导入java.util.ArrayList；
公共类MyCallable实现了Callable{
public List StrList=new ArrayList（）；
公共国际索引，eIndex；
公共MyCallable（列表列表列表、内部si、内部ei）
{
这个。StrList=oList；
这个。sIndex=si；
这个.eIndex=ei；
}
@凌驾
公共列表调用（）引发异常{
for（int i=this.sIndex；i

您正在创建大约128 MB的数据，这些数据将比您的三级缓存大，因此您将把数据推送到主内存，这通常很容易让一个线程饱和。如果您希望线程同时运行，则希望每个线程的大小限制为256 KB（假设它们运行在不同的内核上，则每个线程都有自己的二级缓存），如果它们运行在同一个内核上，则每个线程的大小限制为128 KB。

您的基准测试主要是分配内存，很可能扩展性不太好。您可以尝试

newarraylist（1900000）

至少预先分配列表，但我怀疑这会有多大帮助。在现代JVM中运行的基准代码并不容易，而且你做得不对：你能给我提供一个java代码示例，这样我就可以真正看到应用多线程可以减少执行时间……理论上我知道这是可能的，但实际上我无法生成它。请帮帮我！，谢谢。请将程序更改为CPU密集型，而不是内存或IO密集型。例如，通过递归计算斐波那契数。（显然迭代要快得多，但作为一个例子）