多線程執行時間最小化

Question

下面是我的代碼。 我正在按線程填充大小為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;
  }

}

Answer 1

您正在創建約128 MB的數據，該數據將大於L3緩存，因此您會將數據推出到主內存中，並且通常一個線程就很容易達到飽和。 如果希望線程同時運行，則希望每個線程被限制為256 KB（因為如果它們在不同的內核上運行，則每個線程都有自己的L2緩存），或者如果在同一內核上，則每個線程都限制為128 KB。