多线程处理归并排序的方法一般为：

假设有n个线程同步处理，就将数组等分成n份，每个线程处理一份，再对最后n个有序数组进行归并。

为了使对整个算法具有可扩展性，即线程数n可以自定义，笔者将线程类、处理数组类等进行封装，分为最主要的4个类：Array, Merge, MyThread, MoreThreads，代码如下：

/*Array.java*/

import java.util.ArrayList;

/**

* @author duyue

*

* 这个类用来处理数组

*

* 原理：

* 创建待排序数组成功后，需要配合多线程(假设有n个线程)分别排序，

* 需要将数组尽量等分成n个分数组(保存到列表中)，由n个线程分别归

* 并排序，并将各个有序数组(再次保存到列表中)，最后整合(不归并

* 整合)并覆盖原数组，等待最后归并。

*/

class Array {

/**

* 构造一个保存数组的列表，用于保存分割后的分数组

*/

static ArrayList arrayList = new ArrayList();

/**

* @param length 数组长度

* @return 待排序的数组

*/

static int[] createArray(int length) {

int[] array = new int[length];

for (int i = 0; i < length; i++) {

array[i] = (int) (Math.random() * 10000);

}

return array;

}

/**

* @param array 待分割(多线程排序需要)的数组

* @param num 线程数，即要分割的份数

*/

static void divideArray(int[] array, int num) {

int k = 0; //记录原数组的复制进度，k代表当前数组的复制初始点

for (int i = 0; i < num; i++) {

int point = array.length / num; //分数组的长度

int[] a = new int[0]; //保存分数组

/*考虑到不够整除的情况，将剩余的项全部放在最后一个分数组中*/

if (i != num - 1) a = new int[point];

if (i == num - 1) a = new int[array.length - k];

/*将array[k, k + a.length -1]复制到a[0, a.length]中*/

System.arraycopy(array, k, a, 0, a.length);

arrayList.add(a); //把得到的分数组保存在列表中

k += point; //移动复制初始点

}

}

/**

* @param newArray 由有序分数组整合(不归并)的新数组

* @param num 有序分数组的个数，即由num个线程分别排序后得到的数组数，也就是线程数

*/

static void newArray(int[] newArray, int num) {

/*原理与divideArray方法相似*/

int k = 0; //记录新数组的待整合初始点

/*把列表元素(即数组)逐个复制到新的数组中*/

for (int i = 0; i < num; i++) {

System.arraycopy(arrayList.get(i), 0, newArray, k, arrayList.get(i).length);

k += arrayList.get(i).length; //移动待整合初始点

}

}

}

/*Merge.java*/

/**

* @author duyue

*

* 这是对数组进行归并排序的类

*/

class Merge {

private int[] temp; //暂时存放待排序数组的temp数组

/**

* @param a 待排序的数组由构造器传递到类中

*/

Merge(int[] a) {

temp = new int[a.length];

}

public void sort(int[] a) {

sort(a, 0, a.length - 1);

}

public void sort(int[] a, int low, int high) {

if (low >= high)

return;

int mid = low + (high - low) / 2;

sort(a, low, mid); //将左半边排序

sort(a, mid + 1, high); //将左半边排序

merge(a, low, mid, high); //归并结果

}

/**

* @param a 待归并的数组，其中a[low,mid]和a[mid+1,high]都是有序的

*/

public void merge(int[] a, int low, int mid, int high) {

int i = low, j = mid + 1;

/*将a[low,high]复制到temp[low,high]*/

System.arraycopy(a, low, temp, low, high - low + 1);

/*归并到a[low,high]*/

for (int k = low; k <= high; k++) {

if (i > mid)

a[k] = temp[j++];

else if (j > high)

a[k] = temp[i++];

else if (temp[j] < temp[i])

a[k] = temp[j++];

else

a[k] = temp[i++];

}

}

}

/*MyThread.java*/

import java.util.concurrent.CountDownLatch;

/**

* @author duyue

*

* 这个类用来定义线程，使其能够对数组进行归并排序处理

*/

class MyThread extends Thread {

public int[] aux; //定义一个数组，用来保存待处理的数组

private CountDownLatch latch; //定义这个类用来等待各个线程都完成工作，再进行下一步操作

/*通过构造器将待处理的数组传递到线程的类中*/

public MyThread(int[] aux, CountDownLatch latch) {

this.aux = aux;

this.latch = latch;

}

public void run() {

Merge mergeThread = new Merge(aux);

mergeThread.sort(aux);

latch.countDown();

}

}

/*MoreThreads.java*/

import java.util.ArrayList;

import java.util.concurrent.CountDownLatch;

/**

* @author duyue

*

* 本类是多线程处理归并排序的核心部分。

*

* 原理：

* 由用户指定线程数，例如n个线程，将数组分为n份，分别用n个线程对这n个数组进行归并排序，

* 得到n个有序分数组，再对这n个有序数组归并就得出最后的结果。

* 线程数越多，相应的速度就会越快。

* 要处理的数组长度越长，多线程与单线程的对比就越大。

*/

class MoreThreads {

/**

* @param num 线程数，由用户定义

*/

MoreThreads(int num) {

System.out.println("现在是" + num + "个线程处理归并排序：");

int length = 100; //数组总长度

for (int j = 0; j < 6; j++) {

/*记录起始时间*/

long beginTime = System.currentTimeMillis();

/*创建待排序的数组*/

int[] myArray = Array.createArray(length);

/*将数组近乎等分成num份，以便利用多线程对各个数组排序*/

Array.divideArray(myArray, num);

/*

* 对各个数组利用num个线程同步排序。

* 将num个线程保存在列表threads中，方便将各个线程处理后的数组调出。

* CountDownLatch类用于等待所有的线程都工作完成后，进行最终的归并。

*/

ArrayList threads = new ArrayList();

CountDownLatch latch = new CountDownLatch(num);

for (int i = 0; i < num; i++) {

MyThread thread = new MyThread(Array.arrayList.get(i), latch);

thread.start();

threads.add(thread);

}

try {

latch.await();

} catch (InterruptedException e) {

e.printStackTrace();

}

/*

* 清空原装有数组列表中的元素，

* 将排序后的各个数组从threads列表中调出，添加到数组列表Array中

*/

Array.arrayList.clear();

for (int i = 0; i < num; i++) {

Array.arrayList.add(threads.get(i).aux);

}

/*把各个排序后数组规整到长数组中，并对三个有序数组归并到一个数组中*/

Array.newArray(myArray, num);

/*

* 对有序数组进行归并

* 归并原理：

* 将第一个有序分数组(即第一个线程排序后的数组)与其下一个有序分数组(即第二个线程

* 排序后的数组)归并成一个数组，再把归并的数组与其下一个有序分数组(即第三个线程排

* 序后的数组)归并，依此类推.

*/

int low = 0; //整合后的长数组myArray的首位

int mid = -1; //待归并的第一个有序分数组的末位

int high; //待归并的第二个有序分数组的末位

for (int i = 0; i < num - 1; i++) {

Merge merge = new Merge(myArray);

mid = Array.arrayList.get(i).length + mid;

high = mid + Array.arrayList.get(i + 1).length;

merge.merge(myArray, low, mid, high);

}

/*记录结束时间*/

long endTime = System.currentTimeMillis();

System.out.println(length + "项数组归并排序的时间：" + (endTime - beginTime) + "ms");

length = length * 10;

Array.arrayList.clear(); //清空列表内容，对下一次循环不造成影响

}

}

}

运行以下代码即可测试：

/*TestThread*/

import java.util.Scanner;

/**

* @author duyue

*

* 这是一个测试类，用于展示结果。

*/

public class TestThread {

public static void main(String[] args) {

new MoreThreads(1);

System.out.println("--------------------------------");

new MoreThreads(2);

System.out.println("--------------------------------");

new MoreThreads(3);

System.out.println("--------------------------------");

System.out.println("你还想尝试更多线程处理归并排序吗？(y:yes, n:no)");

while (true) {

Scanner in = new Scanner(System.in);

String s = in.nextLine();

if (s.equals("n")) {

System.out.println("byebye!");

in.close();

break;

} else if (s.equals("y")) {

System.out.println("请输入要尝试的线程数：");

new MoreThreads(in.nextInt());

System.out.println("--------------------------------");

System.out.println("你还想尝试更多线程处理归并排序吗？(y:yes, n:no)");

} else

System.out.println("输入错误！请重新输入");

}

}

}