归并排序多线程化

最新推荐文章于 2022-12-08 10:04:45 发布
最新推荐文章于 2022-12-08 10:04:45 发布
阅读量1.9k 收藏 7
点赞数 1
分类专栏： Think Java 文章标签： 多线程 算法 归并排序 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kiss_xiaojie/article/details/78959664
版权

Multiple thread for the MergeSort

0. 来源

在阅读 Introduction to Algorithm 中多线程一章后，决定自己实现 ++归并排序的多线程化++ 。本以为，它会很简单，而且并发后效果会比较好。然而，实现之路困难重重，并且效果很差。

故，把整个过程记录在此。。。

1. 过程

1.1 从“串行”的归并排序开始

  • 比较简单直接上代码。

    import java.util.Arrays;

public class MergeSortSingle implements MergeSort {

    @Override
    public int[] mergeSortFunction(int[] array) {
        int[] myArray = Arrays.copyOf(array, array.length);
        mergeSort(myArray, 0, myArray.length - 1);
        return myArray;
    }

    private void mergeSort(int[] array, int s, int e) {
        if (s != e) {
            int mid = (s + e) / 2;
            mergeSort(array, s, mid);
            mergeSort(array, mid + 1, e);
            merge(array, s, mid, e);
        }
    }

    private void merge(int[] array, int s, int mid, int e) {
        int[] a1 = Arrays.copyOfRange(array, s, mid + 1);
        int[] a2 = Arrays.copyOfRange(array, mid + 1, e + 1);
        int j = 0;
        int k = 0;
        for (int i = s; i <= e; i++) {
            if (j >= a1.length) {
                array[i] = a2[k];
                ++k;
                continue;
            }
            if (k >= a2.length) {
                array[i] = a1[j];
                ++j;
                continue;
            }
            if (a1[j] < a2[k]) {
                array[i] = a1[j];
                ++j;
            } else {
                array[i] = a2[k];
                ++k;
            }
        }
    }

}
1.2 直接多线程化

  • 可以看到 归并排序 是一种典型的 分治算法 ，它分为 分解 解决 合并 三个部分。我们相对归并排序多线程化，可一下想到从++分解之处++下手，也就是关于的 mergeSort() 的两处调用可以并行执行。

  • 但是，需要注意的是：++考虑并发的同时，必须考虑同步。++ 比如，这里的 merge() 也就是合并过程，必须要等到前面两处分解结束后才能执行。

  • OK，现在有了要并发的目标，实现上最困难之处有以下两点：

    • 如何实现同步，也就是等待两处 mergeSort() 结束后才执行 merge()；
    • 如何管理线程，使用 线程池 or 无需管理；

    从代码中可以看出，这里使用了 ExecutorService 提供的线程池来 管理线程。并且利用了 ReentrantLock & Condition 锁实现 同步。

  • 在使用它们的时候遇到下面两个问题：

    • 线程池的大小（若使用固定大小的线程池往往发生死锁，除非你设置的足够大。因为，此嵌套并行到回溯时才能一一的释放线程，应该画个图）

    • 锁所在的位置（此锁的作用是为了等待。如果把锁作为类的属性，它会把所有的在该锁下等待的都唤醒。然而，它只应该唤醒的对应线程内的。所以，把锁作为类属性会扩大它的范围，导致问题）

      import java.util.Arrays;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class MergeSortPool implements MergeSort {

    private ExecutorService executorService;

    // 锁必须在方法内
//    private ReentrantLock reentrantLock = new ReentrantLock();
//    private Condition condition = reentrantLock.newCondition();

    public MergeSortPool() {
//        this.executorService = Executors.newFixedThreadPool(threadNum);
        this.executorService = Executors.newCachedThreadPool();
    }

    @Override
    public int[] mergeSortFunction(int[] array) {
        int[] myArray = Arrays.copyOf(array, array.length);
        mergeSort(myArray, 0, myArray.length - 1);
        this.executorService.shutdown();
        return myArray;
    }

    // TODO 若线程池设置的太小，则会导致死锁。因为，会出现把所有的线程
    private void mergeSort(int[] array, int s, int e) {
        ReentrantLock reentrantLock = new ReentrantLock();
        Condition condition = reentrantLock.newCondition();
        AtomicBoolean needWait = new AtomicBoolean(true);
        if (s != e) {
            int mid = (s + e) / 2;
            this.executorService.execute(() -> {
                try {
                    mergeSort(array, s, mid);
                } finally {
                    try {
                        reentrantLock.lock();
                        needWait.set(false);
                        condition.signal();
                    } finally {
                        reentrantLock.unlock();
                    }
                }
            });
            mergeSort(array, mid + 1, e);
            try {
                reentrantLock.lock();
                if (needWait.get())
                    condition.await();
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            } finally {
                reentrantLock.unlock();
            }
            merge(array, s, mid, e);
        }
    }

    private void merge(int[] array, int s, int mid, int e) {
        int[] a1 = Arrays.copyOfRange(array, s, mid + 1);
        int[] a2 = Arrays.copyOfRange(array, mid + 1, e + 1);
        int j = 0;
        int k = 0;
        for (int i = s; i <= e; i++) {
            if (j >= a1.length) {
                array[i] = a2[k];
                ++k;
                continue;
            }
            if (k >= a2.length) {
                array[i] = a1[j];
                ++j;
                continue;
            }
            if (a1[j] < a2[k]) {
                array[i] = a1[j];
                ++j;
            } else {
                array[i] = a2[k];
                ++k;
            }
        }
    }
}
1.3 复杂多线程化

在运行了直接多线程化的后，会发现运行时间比串行的长很多。很惊讶，难道是因为它的并行度太低？于是，我开始尝试 复杂多线程化。

说白了，复杂多线程化就是也把归并排序中的合并过程多线程化。很显然，要重新设计 merge() 方法。

  • 串行实现

    新的 merge() 方法也是基于 分治策略 ，所以它上的并行也属于 嵌套并行。详细思路见代码（++说实话，这里走了一些弯路++）。

    // 该类为 “串行” 实现
import java.util.Arrays;

public class MergeImprove implements MergeSort {

    private static int count = 0;

    // TODO you own code and other people's code, because thinking isn't clear.
    // TODO One thinking: take a correct element into a right position util the end of recursion.

    // TODO for the one time call to merge(), saveArray's relevant position is assigned only one time.
    // TODO however, MergeSort will call merge() multiple times, so if don't sync every time, it's going to have a thread safe problem.

    /**
     * merge a1 and a2, a1 and a2 is already sorted array
     *
     * @param s1    the start of a1
     * @param e1    the end of a1
     * @param s2    the start of a2
     * @param e2    the end of a2
     * @param array wait for merging array
     */
    private void merge(int s1, int e1, int s2, int e2, int[] array, int start, int[] saveArray) {
        // 1, make a1 is bigger than a2
        if (e2 - s2 > e1 - s1) {
            int temp = s1;
            s1 = s2;
            s2 = temp;
            temp = e1;
            e1 = e2;
            e2 = temp;
        }
        // 0, solve little problem
        if (e1 - s1 == -1)
            return;
        // 2, get median of the a1
        int medianPos = s1 + (e1 - s1) / 2;
        int median = array[medianPos];
        // 3, get pos and redistribute
        int pos = getPos(median, s2, e2, array);

        int newMedianPos = start + (medianPos - s1) + (pos - s2);
        System.out.println(count + " pos :: " + newMedianPos);
        saveArray[newMedianPos] = array[medianPos];
        merge(s1, medianPos - 1, s2, pos - 1, array, start, saveArray);
        merge(medianPos + 1, e1, pos, e2, array, newMedianPos + 1, saveArray);
    }

    private static int getPos(int num, int start, int end, int[] array) {
        while (end >= start) {
            int mid = (end - start) / 2 + start;
            if (array[mid] >= num) {
                end = mid - 1;
            } else {
                start = mid + 1;
            }
        }
        return start;
    }

    @Override
    public int[] mergeSortFunction(int[] array) {
        int[] saveArray = new int[array.length];
        mergeSort(array, 0, array.length - 1, saveArray);
        return saveArray;
    }

    private void mergeSort(int[] array, int s, int e, int[] saveArray) {
        if (s != e) {
            int mid = (s + e) / 2;
            int[] t = new int[array.length];
            mergeSort(array, s, mid, t);
            mergeSort(array, mid + 1, e, t);
            ++count;
            merge(s, mid, mid + 1, e, t, s, saveArray);
        } else
            saveArray[s] = array[s];
    }

    public static void main(String[] args) {
        int[] array = {2, 9, 1, 8, 2, 10, 18, 21, 12, 5, 7, 4, 3};
        MergeImprove mergeImprove = new MergeImprove();
        int[] saveArray = mergeImprove.mergeSortFunction(array);
        System.out.println(Arrays.toString(saveArray));
    }
}

  • 并行实现

    import java.util.Arrays;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class MergeImprovePool implements MergeSort {

    private ExecutorService executorService;

    public MergeImprovePool() {
        this.executorService = Executors.newCachedThreadPool();
    }

    private void merge(int s1, int e1, int s2, int e2, int[] array, int start, int[] saveArray) {
        // 1, make a1 is bigger than a2
        if (e2 - s2 > e1 - s1) {
            int temp = s1;
            s1 = s2;
            s2 = temp;
            temp = e1;
            e1 = e2;
            e2 = temp;
        }
        // 0, solve little problem
        if (e1 - s1 == -1)
            return;
        // 2, get median of the a1
        int medianPos = (s1 + e1) / 2;
        int median = array[medianPos];
        // 3, get pos and redistribute
        int pos = getPos(median, s2, e2, array);
        int newMedianPos = start + (medianPos - s1) + (pos - s2);
        saveArray[newMedianPos] = array[medianPos];
        int finalS = s1;
        int finalS1 = s2;
        // note1
        AtomicBoolean flag = new AtomicBoolean(false);
        this.executorService.execute(() -> {
            merge(finalS, medianPos - 1, finalS1, pos - 1, array, start, saveArray);
            // note1
            flag.getAndSet(true);
        });
        merge(medianPos + 1, e1, pos, e2, array, newMedianPos + 1, saveArray);
        // note1
        while (!flag.get()) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * maybe should via class libraries
     *
     * @return position
     */
    private static int getPos(int num, int start, int end, int[] array) {
        while (end >= start) {
            int mid = (end - start) / 2 + start;
            if (array[mid] >= num) {
                end = mid - 1;
            } else {
                start = mid + 1;
            }
        }
        return start;
    }

    @Override
    public int[] mergeSortFunction(int[] array) {
        int[] saveArray = new int[array.length];
        mergeSort(array, 0, array.length - 1, saveArray);
        // note2
        /*
        while (((ThreadPoolExecutor) this.executorService).getActiveCount() > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // */
        this.executorService.shutdown();

        return saveArray;
    }

    private void mergeSort(int[] array, int s, int e, int[] saveArray) {
        ReentrantLock reentrantLock = new ReentrantLock();
        Condition condition = reentrantLock.newCondition();
        AtomicBoolean needWait = new AtomicBoolean(true);
        if (s != e) {
            int mid = (s + e) / 2;
            int[] t = new int[array.length];
            this.executorService.execute(() -> {
                try {
                    mergeSort(array, s, mid, t);
                } finally {
                    try {
                        reentrantLock.lock();
                        needWait.set(false);
                        condition.signal();
                    } finally {
                        reentrantLock.unlock();
                    }
                }
            });
            mergeSort(array, mid + 1, e, t);
            try {
                reentrantLock.lock();
                if (needWait.get())
                    condition.await();
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            } finally {
                reentrantLock.unlock();
            }
            merge(s, mid, mid + 1, e, t, s, saveArray);
        } else
            saveArray[s] = array[s];
    }

    public static void main(String[] args) {
        int[] array = {2, 9, 1, 8, 2, 10, 18, 21, 12, 5, 7, 4, 3};
        MergeImprovePool mergeImprovePool = new MergeImprovePool();
        int[] saveArray = mergeImprovePool.mergeSortFunction(array);
        System.out.println(Arrays.toString(saveArray));
    }
}

    实现时，主要发现两个问题（分别在代码中标为 note1 note2）：

    • 为什么需要在 merge() 方法的最后添加同步？
    • note2 处还需不需要？（不需要，若真正了明白上面问题这个问题就可以解决了）

    针对 note1 的问题，理解过程如下：

    1. 通过分析 merge() 方法，我们可以知道对它的一次调用只会对 saveArray 数组的相应位置进行一次赋值。由此，我们可能会想到多线程下也是安全的；确实，若只对它进行一次调用，这个判断是对的；
    2. 所以，一开始并没有在 merge() 方法最后添加同步 sync。也就是等待所有完成后，才退出。然而，在测试时发现结果中有好多 0，并且会在一定概率下成功~~~
    3. 一开始我以为是 ++线程池的问题++，线程管理出现问题，线程池关闭过早？？？经调试，发现所有的排序过程都执行了，这肯定不是线程池的锅了；
    4. 经过一下午的调试，终于发现少了 sync 操作，mmp！添加后（也就是 note1 处），立马跑通！！
    5. 为什么呢？MergeSort() will call merge() multiple times, so if don’t sync every time, it’s going to have a thread safe problem. 加上后，回溯 过程会一一调用 merge()，而不会出现多个 merge() 调用同时存在！

2. 比较

方法数量时间
MergeSort100000.025
MergeSortThread100003.127
MergeSortPool100001.018
MergeImprove100000.127
MergeImprovePool100002.207
MergeSort1000000.043
MergeSortThread100000230.621
MergeSortPool1000002.791
MergeImprove1000004.321
MergeImprovePool100000outofmemory

3. 总结

结果分析，请参考。

任重而道远！！！

INotWant
关注
专栏目录
如何用多线程实现归并排序
菜鸟修仙记
08-09 7439
等我有时间了，一定要把《算法导论》啃完，这本书的印刷质量实在太好了，滑稽。 之前听吴恩达老大说过Python里面的Numpy包的矩阵运算就是多线程的，所以能做到的情况下尽量用矩阵运算代替循环，这样能大大加快运算的速度。 为了提高速度，如果不涉及外部资源读取的话，要提高运行速度就要做到并行计算，依赖于处理器的数量；如果需要等待耗时的外部资源读取，就可以通过并发边读边运算。 算法导论有一章节提到...
java多线程实现归并排序_排序算法Java实现（归并排序）
weixin_29113833的博客
02-16 172
package sorting;/*** 归并排序* 平均O(nlogn),最好O(nlogn),最坏O(nlogn);空间复杂度O(n);稳定;较复杂* @author zeng**/public class MergeSort {public static void merge(int[] a, int start, int mid,int end) {int[] tmp = new int[...
归并排序的多线程实现
05-11
对大规模文件进行排序操作,首先将文件分割以便在内存中进行内排序.使用堆排序的方法对每个子文件排序.多线程实现.
归并排序 -- 多线程版本
fuzekun的博客
05-21 558
近期学了Java多线程的一些关键字还有设计模式的代理模式，在这应用一下。先写下版本1，以后在逐渐进行改进。 环境 jdk 8+ maven cglib 思路 这里主要实现了三个类。 进行数组生成和打印以及其他数组操作的SortUtil类。 进行时间统计的代理类TimeProxy，使用cglib生成代理类。 进行主逻辑实现的SortThread类。 代码 SortUtil类 package threadBase.threadPool; import java.util.Random; /**
多线程实现归并排序
weixin_45693672的博客
04-08 804
多线程实现归并排序 有点简单直接上代码，呜呜呜 // // merge_sort.c // merge_sort // 多线程方法 // Created by Yibin on 2021/4/8. // Copyright © 2021 Yibin. All rights reserved. // #include <stdio.h> #include <stdlib.h> #include <pthread.h> #include <string.h&g
java多线程实现归并排序_利用多线程对数组进行归并排序
weixin_42509409的博客
02-16 977
多线程处理归并排序的方法一般为：假设有n个线程同步处理，就将数组等分成n份，每个线程处理一份，再对最后n个有序数组进行归并。为了使对整个算法具有可扩展性，即线程数n可以自定义，笔者将线程类、处理数组类等进行封装，分为最主要的4个类：Array, Merge, MyThread, MoreThreads，代码如下：/*Array.java*/import java.util.ArrayList;/*...
C语言实现多线程的归并排序
勇敢前进的ACMer
04-03 5405
C语言实现多线程的归并排序 问题 ​ 利用多线程实现归并排序。归并排序是分治算法的代表，适合改写为多线程。 构造数据 ​ 数据规模为2∗1062*10^62∗106,整数。array_length=2∗106array\_length = 2*10^6array_length=2∗106 srand((int)time(NULL)); for (int i = 0; i < ...
归并方式的多线程快速排序算法.txt
05-26
### 归并方式的多线程快速排序算法 #### 摘要与研究背景 本文主要探讨了在Java平台上利用归并方式实现的多线程快速排序算法，并对其进行了性能评估。快速排序作为霍尔（Hoare）提出的一种经典排序算法，其基本思想...
C++实现归并排序算法
12-20
归并排序是一种基于分治策略的高效排序算法，它的核心思想是将大问题分解为小问题，然后分别解决这些小问题，最后将解决方案合并，从而得到整个问题的解。在归并排序中，我们将待排序的序列分为两部分，对每一部分...
VC++多线程实现三种排序算法比较----冒泡排序、快速排序、归并排序
10-09
VC++多线程实现三种排序算法比较----冒泡排序、快速排序、归并排序，很有意思，可以下载看看！
java多线程实现归并排序_【Java高级】利用fork-join框架归并排序来比较性能
weixin_42361874的博客
02-13 226
fork-join框架会使用空闲线程来抢占当前线程的任务，具体实现原理这里就不说了，有兴趣的同学也可以自己实现一个。这里使用该框架进行归并排序，并对比普通的归并排序的效率：import java.util.ArrayList;import java.util.List;import java.util.Random;import java.util.concurrent.ForkJoinPool;...
排序：多线程版本的归并排序
月光骆驼的博客
06-26 790
多线程版本的归并排序 这里的TR和TR2都无需加锁，因为每个Msort处理的数据段都是不一样的。 #include <iostream> #include <thread> #include <vector> using namespace std; void merge(vector<int> TR2, vector<int>&a...
多线程算法--归并排序
cool grass's blog
06-22 865
如下： #include <pthread.h> #include <iostream> #include <fstream> #include <string> #include <vector> #include <cstdlib> #include <typeinfo> #include <algori...
多线程归并排序
阿鲁拔的博客
07-05 4315
归并排序是典型的分治算法，所以可以用多线程来解决，在Linux平台上进行多线程编程，必须在编译时链接Linuxthread库，如下图所示： 因为比较简单，就直接上代码了，讲各种排序的博客也比较多。 #include #include #include #include int *array_master; /* 归并函数 */ void merge(int arr[], i
Java多线程-归并排序
qq_43613152的博客
09-21 371
java多线程实现的归并排序 import java.util.Arrays; import java.util.concurrent.ForkJoinPool; import java.util.concurrent.ForkJoinTask; import java.util.concurrent.RecursiveTask; public class MergePiggy { public static void main(String[] args) throws Exception
归并排序之多线程实现（C++）
XindaBlack的博客
06-27 1958
归并排序使用多线程分析 归并排序分为两步： 不断地对半拆分数组（向下的过程）； 合并相邻的子数组（向上的过程）。 对于拆分成的子数组，它们之间相互独立，资源不共享，因此用多线程是安全的。（在合并前，两个子线程需要运行完毕，即join阻塞当前线程直到两个子线程运行完毕） C++代码 #include <iostream> #include <thread> #include <vector> #include <functional> using name
C++：多线程编程学习:利用多线程进行归并排序。
pyb的博客
09-08 3266
#include <pthread.h> #include <iostream> #include <fstream> #include <string> #include <vector> #include <cstdlib> #include "unistd.h" using namespace std;#define NUM_THREADS 5vector<int> read_file(str
多线程并行归并排序算法实现
最新发布
qq_34999565的博客
12-08 326
排序优化工程实现
Java平台归并多线程快速排序：性能提升与教学应用
归并排序通常用于合并有序序列，这里被用来减少单线程快速排序中的递归调用次数，同时利用多核处理器的并行处理能力。在Java环境下，作者首先验证了在小数据量情况下优化的有效性，随后开发了一种归并方式的多线程...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值