スレッド数が増えると実行時間が短縮されますか？

Question

以下の私のコードでは、以前の記事を読んだことがあります。しかし、私のスレッドの理解に基づいて、私は文脈の切り替えのために、より多くのスレッドで時間が全体的に増加することを理解しています。しかし、このコードを実行すると、実行時間が厳しくなります。私はこれを間違って実装していますか？これは私のシステムのためです。あなたが使用するスレッドの実際の数がダウンしたスレッド（args[0]）の数を増やす場合は

import java.io.File; 
import java.io.FileNotFoundException; 
import java.util.ArrayList; 
import java.util.Scanner; 

public class MeanThread { 
    public static void main(String[] args) throws InterruptedException, FileNotFoundException { 
     Scanner s = new Scanner(new File("/Users/Bryan/Desktop/personal/Code/Java/Lab 2/src/input.txt")); 
     ArrayList<Integer> listOfValues = new ArrayList<Integer>(); 
     ArrayList<Double> temporalMeanArray = new ArrayList<Double>(); 
     Double temporalMean = 0.0; 
     while (s.hasNextInt()) { 
      int number = s.nextInt(); 
      listOfValues.add(number); 
     } 
     // define number of threads 
     // this way, you can pass number of threads as 
     // a second command line argument at runtime. 
     int NumOfThread = Integer.parseInt(args[0]); 
     // TODO: partition the array list into N subArrays, where N is the number of threads 
     ArrayList<ArrayList<Integer>> listOfSubArrays = new ArrayList<ArrayList<Integer>>(NumOfThread); 
     for (int i = 0; i < listOfValues.size(); i += NumOfThread) { 
      listOfSubArrays.add(new ArrayList<Integer>(listOfValues.subList(i, Math.min(i + NumOfThread, listOfValues.size())))); 
     } 
     // TODO: start recording time 
     //Tip: you can't create big number of threads in the above way. So, create an array list of threads. 
     ArrayList<MeanMultiThread> threadList = new ArrayList<MeanMultiThread>(); 
     for (int i = 0; i < listOfSubArrays.size(); i ++) { 
      threadList.add(new MeanMultiThread(listOfSubArrays.get(i))); 
     } 
     // TODO: start each thread to execute your computeMean() function defined under the run() method 
      //so that the N mean values can be computed. for example, 
     int threadCounter = 1; 
     long startTime = System.currentTimeMillis(); 
     for (MeanMultiThread mmt : threadList) { 
      mmt.start(); 
     } 

     for (MeanMultiThread mmt : threadList) { 
      mmt.join(); 
      System.out.println("Temporal mean value of thread " + threadCounter + " is " + mmt.getMean()); 
      threadCounter ++; 
      temporalMeanArray.add(mmt.getMean()); 
     } 

     for (Double d : temporalMeanArray) { 
      temporalMean += d; 
     } 
     Double globalMean = temporalMean/temporalMeanArray.size(); 
     long endTime = System.currentTimeMillis(); 
     long elapsedTime = endTime - startTime; 
     System.out.println("Total elapsed time is " + elapsedTime + " milliseconds."); 
     System.out.println("The global mean value is " + globalMean); 

    } 
} 
//Extend the Thread class 
class MeanMultiThread extends Thread { 
    private ArrayList<Integer> list; 
    private double mean; 
    int counter = 0; 
    MeanMultiThread(ArrayList<Integer> array) { 
     list = array; 
    } 
    public double getMean() { 
     return mean; 
    } 
    public void run() { 
     mean = computeMean(list); 

    } 
    private double computeMean(ArrayList<Integer> list2) { 
     double totalAmount = 0.0; 
     for (int i : list2) { 
      totalAmount += i; 
     } 
     return totalAmount/(list2.size()); 
    } 
} 

Answer 1

（私はMacBook Proの2015を使用しています）。その理由は、サブアレイのバケットサイズとしてNumOfThreadを使用しているためです。バケツサイズを大きくすると、バケツが少なくなり、スレッド数が少なくなります。問題のある行は関係なく、スレッド数のバケットサイズを一定に保ち、その後、あなたは意味のある結果を得ることができます

for (int i = 0; i < listOfSubArrays.size(); i ++) { 

とともに

for (int i = 0; i < listOfValues.size(); i += NumOfThread) { 

です。ワークロードが完全にCPUバウンドであるため、CPUが同時に処理できるスレッドよりも多くのスレッドを持つとすぐに意味のあるスピードアップは得られません。