螺纹排序运行速度比非线程排序慢

Question

我想使用线程对文件进行排序。这里是Sort.java：

此功能排序与线程

public static String[] threadedSort(File[] files) throws IOException { 
     String sortedData[] = new String[0]; 
     int counter = 0; 
     boolean allThreadsTerminated = false; 
     SortingThread[] threadList = new SortingThread[files.length]; 
     for (File file : files) { 
      String[] data = getData(file); 
      threadList[counter] = new SortingThread(data); 
      threadList[counter].start(); 
      counter++; 
     } 
     while(!allThreadsTerminated) { 
      allThreadsTerminated = true; 
      for(counter=0; counter<files.length; counter++) { 
       if(threadList[counter].getState() != Thread.State.TERMINATED) { 
        allThreadsTerminated = false;    
       }   
      } 
     } 
     for(counter=0; counter<files.length; counter++) { 
      sortedData = MergeSort.merge(sortedData, threadList[counter].data); 
     } 
     return sortedData; 
} 

此功能只是各种正常的帮助，现在

public static String[] sort(File[] files) throws IOException { 
    String[] sortedData = new String[0]; 
    for (File file : files) { 
     String[] data = getData(file); 
     data = MergeSort.mergeSort(data); 
     sortedData = MergeSort.merge(sortedData, data); 
    } 
    return sortedData; 
    } 

当我用那种左右逢源的正常排序是比螺纹快版。什么可能是它的原因？我错过了什么？

我SortingThread是这样的：

public class SortingThread extends Thread { 
    String[] data; 
    SortingThread(String[] data) { 
     this.data = data; 
    } 
    public void run() { 
     data = MergeSort.mergeSort(data);   
    } 
} 

当我分析一下我通过它的性能比较原始的非线程实现线程实现，我觉得第二个快。什么可能是这种行为的原因？如果我们谈论相对的性能改进，我们希望线程实现速度更快，如果没有错的话。

编辑：假设我有适当的功能MergeSort。但是没有必要在这里发布它的代码。另外getData（）函数只是从文件中获取输入。 我认为问题在于我正在整个文件中的数组。我认为我应该提供不同的线，以不同的线程：

private static String[] getData(File file) throws IOException { 
    ArrayList<String> data = new ArrayList<String>(); 
    BufferedReader in = new BufferedReader(new FileReader(file)); 
    while (true) { 
     String line = in.readLine(); 
     if (line == null) { 
     break; 
     } 
     else { 
     data.add(line); 
     } 
    } 


    in.close(); 
    return data.toArray(new String[0]); 
    } 

Answer 1

首先，你如何测量流逝的时间？你在同一个程序中执行两个测试吗？如果是这样，请记住mergesort可能会在第一次测试执行时进行热点编译。我建议你运行每种方法两次，测量第二次运行的时间

Answer 2

你有多少个CPU /内核？这段代码的一个问题是主线程在“while（！allThreadsT​​erminated）”循环中花费CPU时间，主动检查线程状态。如果你有一个CPU - 你正在浪费它，而不是实际的排序。

for(counter=0; counter<files.length; counter++) { 
     threadList[counter].join(); 
} 

Answer 3

您应该使用流和标准排序：

与更换while循环

static String[] sort(File[] files, boolean parallel) { 
    return (parallel ? Stream.of(files).parallel() : Stream.of(files)) 
     .flatMap(f -> { 
      try { 
       return Files.lines(f.toPath()); 
      } catch (Exception e) { 
       e.printStackTrace(); 
       return null; 
      } 
     }) 
     .sorted() 
     .toArray(String[]::new); 
} 

static String[] sort(File[] files) { 
    return sort(files, false); 
} 

static String[] threadSort(File[] files) { 
    return sort(files, true); 
} 

在我environmet threadSort更快。

sort: 
files=511 sorted lines=104419 elapse=4784ms 
threadSort: 
files=511 sorted lines=104419 elapse=3060ms 

Answer 4

您可以使用java.util.concurrent.ExecutorService将在线程的指定数量的运行所有的任务，而一旦所有线程都执行完毕后，你会得到一个列表Future对象将举行每个线程执行的结果。未来对象列表将按照您将Callable对象插入列表中的顺序排列。

首先你需要的是让你的SortingThread实现Callable接口，这样你就可以得到每个线程执行的结果。
每个Callable对象必须实现call()方法，其返回类型将是您的Future对象。

public class SortingThread implements Callable<String[]> { 
    String[] data; 
    SortingThread(String[] data) { 
     this.data = data; 
    } 
    @Override 
    public String[] call() throws Exception { 
     data = MergeSort.mergeSort(data); 
     return data; 
    } 
    } 

接下来你需要的是使用ExecutorSerivce进行线程管理。

public static String[] sortingExampleWithMultiThreads(File[] files) throws IOException { 
     String sortedData[] = new String[0]; 
     int counter = 0; 
     boolean allThreadsTerminated = false; 
     SortingThread[] threadList = new SortingThread[files.length]; 
     ArrayList<Callable<String[]>> callableList = new ArrayList<Callable<String[]>>(); 
     for (File file : files) { 
      String[] data = getData(file); 
      callableList.add(new SortingThread(data)); //Prepare a Callable list which would be passed to invokeAll() method. 
      counter++; 
     } 

     ExecutorService service = Executors.newFixedThreadPool(counter); // Create a fixed size thread pool, one thread for each file processing... 
     List<Future<String[]>> futureObjects = service.invokeAll(callableList); //List of what call() method of SortingThread is returning... 

     for(counter=0; counter<files.length; counter++) { 
      sortedData = MergeSort.merge(sortedData, futureObjects.get(counter)); 
     } 
     return sortedData; 
} 

这样你能避免使用WHILE循环这是众所周知的提高CPU利用率（因此在速度降低），并且如果你有单核CPU然后它可以达到的利用率为100％，而如果双核心然后是50％。
另外，使用ExecutorService进行线程管理是处理多线程而不是dev启动和监视线程以获得结果的更好方法。 所以，你可以期待性能。

我还没有跑过它，所以你可能需要这样做，改变这里和那里，但我突出了你的方法。

P.S .:在衡量性能时，为了得到整洁和精确的结果，总是为每次运行创建一个新的JVM实例。