單線程排序和利用Fork/Join進行多線程並行排序的簡單對比
Fork/Join框架自從在JDK7中引進以後，對並行計算的設計帶來了更多便利。java
本文使用java原生的排序方法Array.sort單線程排序，和利用Fork/Join框架進行任務分割設計的快速排序進行對比。多線程
首先，使用如下方法構造一個簡單的文件樣本，目標是生成一個文本文件，10000000行，每行爲一個20000之內的隨機數：框架
package sort;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Random;
public class GenerateSample {
public static void main(String[] args) {
File f = new File("/home/nox/java/sort/sample.txt");
FileWriter writer;
try {
writer = new FileWriter(f, false);
Random random1 = new Random(10);
for (int i = 0; i < 10000000; i++) {
writer.write(String.valueOf(random1.nextInt(20000)));
writer.write("\r\n");
}
writer.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
}
}
}
運行以後，能夠看到文件信息的片斷以下：dom
168890149 Aug 9 21:59 sample.txt
能夠看到該文件的大小爲168MB左右，可能根據操做系統的不一樣略有差別。測試
而後，咱們將使用下面的普通排序方式對該文件裏面的數據進行排序而後輸出，由於本文的目標僅僅是簡單的測算排序的速度，因此對IO並無進行任何優化，僅僅是將文件裏面的數據進行讀取而後排序。故下面的代碼也只對排序過程所耗費的時間進行計算。代碼以下：優化
package sort;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class ArraySort {
public static void main(String args[]) {
File f = new File("/home/nox/java/sort/sample.txt");
List arrayList = new ArrayList();
try {
BufferedReader reader = new BufferedReader(new FileReader(f));
String str = null;
while ((str = reader.readLine()) != null) {
arrayList.add(Integer.valueOf(str));
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
long startTime=System.currentTimeMillis();
Collections.sort(arrayList);
long endTime=System.currentTimeMillis();
System.out.println("排序所花時間:"+(endTime-startTime)+"ms");
File f2 = new File("/home/nox/java/sort/original_sorted.txt");
FileWriter writer2;
try {
writer2 = new FileWriter(f2, false);
for (int i = 0; i < arrayList.size(); i++) {
writer2.write(String.valueOf(arrayList.get(i)));
writer2.write("\r\n");
}
writer2.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
}
}
}
輸出結果爲：this
排序所花時間:16259ms
能夠看到排序話費的時間爲16259ms，說明一下， 此處運行程序並無對JVM參數進行任何調整，只是簡單測試運行的結果，因此在不一樣的計算機硬件配置和不一樣的操做系統下，可能會有誤差。操作系統
而後，咱們使用基於 Fork/Join 框架的多線程並行化設計的快速排序進行排序。看看所耗費的時間如何。代碼以下：線程
package sort;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;
import java.util.concurrent.RecursiveTask;
public class FastSortByForkAndJoin {
public static void main(String args[]) {
File f = new File("/home/nox/java/sort/sample.txt");
List arrayList = new ArrayList();
try {
BufferedReader reader = new BufferedReader(new FileReader(f));
String str = null;
while ((str = reader.readLine()) != null) {
arrayList.add(Integer.valueOf(str));
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
long longArray[] = new long[arrayList.size()];
for( int i =0;i<arrayList.size();i++){
longArray[i] = Long.parseLong(arrayList.get(i).toString());
}
ForkJoinPool pool = new ForkJoinPool();
FastSort fastSort = new FastSort(longArray);
long startTime=System.currentTimeMillis();
pool.execute(fastSort);
while(!fastSort.isDone()){
}
long endTime=System.currentTimeMillis();
System.out.println("排序所花時間:"+(endTime-startTime)+"ms");
File f2 = new File("/home/nox/java/sort/fastSorted.txt");
FileWriter writer2;
try {
writer2 = new FileWriter(f2, false);
for (int i = 0; i < longArray.length; i++) {
writer2.write(String.valueOf(longArray[i]));
writer2.write("\r\n");
}
writer2.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
}
}
}
class FastSort extends RecursiveAction {
final long[] array;
final int lo;
final int hi;
private int THRESHOLD = 30;
public FastSort(long[] array) {
this.array = array;
this.lo = 0;
this.hi = array.length - 1;
}
public FastSort(long[] array, int lo, int hi) {
this.array = array;
this.lo = lo;
this.hi = hi;
}
protected void compute() {
if (hi - lo < THRESHOLD)
sequentiallySort(array, lo, hi);
else {
int pivot = partition(array, lo, hi);
FastSort left = new FastSort(array, lo, pivot - 1);
FastSort right = new FastSort(array, pivot + 1, hi);
invokeAll(left, right);
}
}
private int partition(long[] array, int lo, int hi) {
long x = array[hi];
int i = lo - 1;
for (int j = lo; j < hi; j++) {
if (array[j] <= x) {
i++;
swap(array, i, j);
}
}
swap(array, i + 1, hi);
return i + 1;
}
private void swap(long[] array, int i, int j) {
if (i != j) {
long temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
private void sequentiallySort(long[] array, int lo, int hi) {
Arrays.sort(array, lo, hi + 1);
}
}
輸出結果爲：設計
排序所花時間:2212ms
能夠看到，排序時間比以前的方式要少不少。
總結：在多線程方式下，儘管咱們沒有對JVM參數，線程數量和單任務中的閾值進行更多的優化，僅僅是一個簡單的多線程快速排序，在速度上就已經遠勝普通的排序方式，相信若是在數據樣本更大的狀況下，進行更多的優化，排序的速度勢必會有更大的差別。
相關文章
- 1. 利用多線程對數組進行歸併排序
- 2. 使用歸併排序對鏈進行排序（超簡單）
- 3. 多線程歸併排序
- 4. 進程和線程的簡單對比
- 5. 使用C++11進行多線程歸併排序:std::thread
- 6. 用多線程進行的序列快速排序
- 7. 多線程對800萬個數據進行排序
- 8. 單線程和多線程執行對比—Python多線程編程
- 9. 多線程排序+快速排序
- 10. 對單鏈表進行重排序
- 更多相關文章...
- • C# 多線程 - C#教程
- • Eclipse 運行程序 - Eclipse 教程
- • 算法總結-歸併排序
- • TiDB 在摩拜單車在線數據業務的應用和實踐
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. 利用多線程對數組進行歸併排序
- 2. 使用歸併排序對鏈進行排序（超簡單）
- 3. 多線程歸併排序
- 4. 進程和線程的簡單對比
- 5. 使用C++11進行多線程歸併排序:std::thread
- 6. 用多線程進行的序列快速排序
- 7. 多線程對800萬個數據進行排序
- 8. 單線程和多線程執行對比—Python多線程編程
- 9. 多線程排序+快速排序
- 10. 對單鏈表進行重排序