技术文章 > java >  java基础 > 正文

Java多线程排序使用

小妮浅浅

本教程操作环境:windows7系统、java10版,DELL G3电脑。

1.先试一下我们不用多线程的情况,以快速排序为例

package advance1;/*
 * @Author: Gnight
 * @Date: 2020/12/17 23:32
 * @Description:
    单线程的快速排序,太多数据栈会溢出
 */
 
import java.util.Arrays;
 
public class JavaDemo {
 
    public static int[] arr;
 
    public static void main(String[] args) {
        //随机生成数值
        arr = new int[100];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 1000);
        }
        new JavaDemo().doSort(0, arr.length - 1);
        for (int element : arr) {
            System.out.println(element);
        }
    }
 
    public void doSort(int low, int high) {
        if (low < high) {
            int index = quickSort(low, high);//实际的排序流程
            doSort(low, index - 1);
            doSort(index + 1, high);
        }
    }
 
    public int quickSort(int i, int j) {
        int key = arr[i];//基准值
        while (i < j) {
            //找出第一个右边要交换的
            while (i < j && arr[j] >= key) j--;
            if (i < j) arr[i] = arr[j];
            //找出第一个左边要交换的
            while (i < j && arr[i] <= key) i++;
            if (i < j) arr[j] = arr[i];
        }
        // i== j的情况
        arr[i] = key;
        return i;
    }
}

2.数据分段

//根据我们设立的线程数来分段
for (int i = 0; i < threadNum; i++) {
    int[] temp = Arrays.copyOfRange(arr, i * arr.length / threadNum, 
       	(i + 1) * arr.length / threadNum);
    //theadNum就是线程数
}
快排线程:采用Callable接口,可以有返回值
package advance1;/*
 * @Author: Gnight
 * @Date: 2020/12/17 19:10
 * @Description:
    多线程实现快排
 */
 
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
 
//快排多线程
public class sortThread implements Callable<int[]> {
 
    private int[] arr;
    private int low;
    private int high;
    private CountDownLatch count;
 
    public sortThread(int[] arr, int low, int high, CountDownLatch count) {
        this.arr = arr;
        this.low = low;
        this.high = high;
        this.count = count;
    }
 
    public int[] call() throws Exception {
        System.out.println("线程 " + Thread.currentThread().getName() + " 开始");
        doSort(low, high);
        int[] res = new int[high - low + 1];
        int index = 0;
        for (int i = low; i < high + 1; i++) {
            res[index++] = arr[i];
        }
        try {
            return arr;
        } finally {
            count.countDown();
            System.out.println("线程 " + Thread.currentThread().getName() + " 结束");
        }
    }
 
    public void doSort(int low, int high) {
        if (low < high) {
            int index = quickSort(low, high);//实际的排序流程
            doSort(low, index - 1);
            doSort(index + 1, high);
        }
    }
 
    public int quickSort(int i, int j) {
        int key = arr[i];//基准值
        while (i < j) {
            //找出第一个右边要交换的
            while (i < j && arr[j] >= key) j--;
            if (i < j) arr[i] = arr[j];
            //找出第一个左边要交换的
            while (i < j && arr[i] <= key) i++;
            if (i < j) arr[j] = arr[i];
        }
        // i== j的情况
        arr[i] = key;
        return i;
    }
}

3.创建多线程,使用CountDownLatch保证前面都完成后再对数据段合并

try {
    CountDownLatch count = new CountDownLatch(threadNum);
    for (int i = 0; i < threadNum; i++) {
        int[] temp = Arrays.copyOfRange(arr, i * arr.length / threadNum, (i + 1) * arr.length / threadNum);
        Future<int[]> future = pool.submit(new sortThread(temp, 0,
                        temp.length - 1, count));
        res[i] = future.get();
    }
    /*
    使用CountDownLatch来保证前面线程都排序完,然后对排序完的升序数组合并
    */
    count.await();
    //这里排序亦可使用多线程
    int[] m1 = merge(res[0], res[1]);
    int[] m2 = merge(res[2], res[3]);
    arr = merge(m1, m2);
} catch (Exception e) {
    e.printStackTrace();
}

以上就是java多线程排序的方法,大家可以跟着小编的流程尝试下。

本文来源于网络,如有雷同联系作者修改。

免费视频教程
本教程部分素材来源于网络,版权问题联系站长!
相关文章
  Java基础中注释添加的位置以及原则详解
  Java基础里的@Target是什么?怎么用?
  Java基础@Retention如何创建注解?
  Java基础之内置注解有哪些?
  Java基础:有哪些版本可以选择?区别是什么?
相关视频章节
  定位&布局
  CSS常用属性
  网页布局盒子模型
  组合选择器
  CSS id & class 选择器
作者信息
推荐视频
视频教程分类