2. 程式人生 > >如何用多執行緒實現歸併排序

如何用多執行緒實現歸併排序

阿新 • • 發佈：2018-12-23

等我有時間了，一定要把《演算法導論》啃完，這本書的印刷質量實在太好了，滑稽。

之前聽吳恩達老大說過Python裡面的Numpy包的矩陣運算就是多執行緒的，所以能做到的情況下儘量用矩陣運算代替迴圈，這樣能大大加快運算的速度。

為了提高速度，如果不涉及外部資源讀取的話，要提高執行速度就要做到平行計算，依賴於處理器的數量；如果需要等待耗時的外部資源讀取，就可以通過併發邊讀邊運算。

演算法導論有一章節提到了並行迴圈，多執行緒矩陣乘法和多執行緒歸併排序，方法都是講一個大的計算過程分成幾個獨立的小部分，各個部分讓單獨的執行緒去計算。

排序裡面講問題分解的典型的就有快排和歸併，接下來看一下怎麼寫多執行緒的。

多執行緒歸併排序

直接點的思考方式，歸併排序先要把一個數據分成兩個，然後這兩個分別歸併排序，拍完了把兩個歸併到一起，典型的遞迴。

那麼我們直接點，先把陣列分割好，然後開兩個執行緒，一個執行緒給一個，等著兩個執行緒都搞定了，在把兩個結果合併起來。或者你覺得兩個執行緒每個要處理的還是太長了，那就在這兩個執行緒裡面再把拿到的陣列分割了，各自再開兩個。嘗試一下

先看下單執行緒的版本，做下測試

import java.util.Random;

public class Main {
    public static void main(String[] args) {
        int length = 1000;
        int[] data = (new Data(length)).getData();
        printArr(data);
        System.out.println();
        mergeSort(data);
        printArr(data);
    }

    //遞迴
    private static void mergeSort(int[] nums,int[] tmp,int left,int right){
        if(left<right){
            int center = (left+right)/2;
            mergeSort(nums,tmp,left,center);
            mergeSort(nums,tmp,center+1,right);
            merge(nums,tmp,left,center+1,right);
        }
    }

    //合併
    private static void merge(int[] nums,int[] tmp,int leftPos, int rightPos, int rightEnd){
        int leftEnd = rightPos-1;
        int tmpPos = leftPos;
        int numElements = rightEnd - leftPos + 1;
    
        while(leftPos<=leftEnd&&rightPos<=rightEnd){
            if(nums[leftPos]<nums[rightPos])
                tmp[tmpPos++]=nums[leftPos++];
            else 
                tmp[tmpPos++]=nums[rightPos++];
        }
        while(leftPos<=leftEnd)
            tmp[tmpPos++]=nums[leftPos++];
        
        while(rightPos<=rightEnd)
            tmp[tmpPos++]=nums[rightPos++];
    
        for(int i = 0;i<numElements;i++,rightEnd--)
            nums[rightEnd]=tmp[rightEnd];
    }
    public static void mergeSort(int[] nums){
        int[] tmp = new int[nums.length];
        mergeSort(nums,tmp,0,nums.length-1);
    }
    
    //列印
    public static void printArr(int[] arr) {
        for(int i : arr){
            System.out.print(i+" ");
        }
    }


}


/**
 * 產生隨機資料
 */
class Data{
    int length;
    int[] data;

    public Data(int length){
        this.length = length;
        data = new int[length];
    }

    public int[] getData(){

        Random random = new Random(System.currentTimeMillis());
        for(int i=0;i<length;i++){
            data[i]=random.nextInt(2*length);
        }
        return data;
    }


}

可以看到演算法是能正常執行的

按上面思路的多執行緒版本呢？用 兩個執行緒試驗了下

只修改了main函式，加入了一個verify用作驗證排序是不是OK的，不能人眼看吧

import java.util.Random;
import java.util.concurrent.CountDownLatch;

public class Main {
    public static void main (String[] args) throws InterruptedException {
        int length = 1000;
        int[] data = (new Data(length)).getData();
        printArr(data);
        System.out.println();
        // mergeSort(data);
        //在這裡修改
        int center = data.length/2;

        int[] tmp = new int[data.length];
        CountDownLatch latch = new CountDownLatch(2);//CountDownLatch能夠使一個執行緒在等待另            
                                                    //外一些執行緒完成各自工作之後，再繼續執行
        new Thread(new Runnable(){
        
            @Override
            public void run() {
                mergeSort(data,tmp,0,center);
                latch.countDown();
            }
        }).start();

        new Thread(new Runnable(){
        
            @Override
            public void run() {
                mergeSort(data,tmp,center+1,data.length-1);
                latch.countDown();
            }
        }).start();

        latch.await();

        merge(data, tmp, 0, center+1, data.length-1);

        printArr(data);
        System.out.println();
        verify(data);
    }

    //遞迴
    private static void mergeSort(int[] nums,int[] tmp,int left,int right){
        if(left<right){
            int center = (left+right)/2;
            mergeSort(nums,tmp,left,center);
            mergeSort(nums,tmp,center+1,right);
            merge(nums,tmp,left,center+1,right);
        }
    }

    //合併
    private static void merge(int[] nums,int[] tmp,int leftPos, int rightPos, int rightEnd){
        int leftEnd = rightPos-1;
        int tmpPos = leftPos;
        int numElements = rightEnd - leftPos + 1;
    
        while(leftPos<=leftEnd&&rightPos<=rightEnd){
            if(nums[leftPos]<nums[rightPos])
                tmp[tmpPos++]=nums[leftPos++];
            else 
                tmp[tmpPos++]=nums[rightPos++];
        }
        while(leftPos<=leftEnd)
            tmp[tmpPos++]=nums[leftPos++];
        
        while(rightPos<=rightEnd)
            tmp[tmpPos++]=nums[rightPos++];
    
        for(int i = 0;i<numElements;i++,rightEnd--)
            nums[rightEnd]=tmp[rightEnd];
    }
    public static void mergeSort(int[] nums){
        int[] tmp = new int[nums.length];
        mergeSort(nums,tmp,0,nums.length-1);
    }
    
    //列印
    public static void printArr(int[] arr) {
        for(int i : arr){
            System.out.print(i+" ");
        }
    }
    
    public static void verify(int[] nums) {
        for(int i=0;i<nums.length-1;i++){
            if(nums[i]>nums[i+1]){
                System.out.println("排序失敗");
                return;
            } 

        }
        System.out.println("排序成功");
    }
    


}


/**
 * 產生隨機資料
 */
class Data{
    int length;
    int[] data;

    public Data(int length){
        this.length = length;
        data = new int[length];
    }

    public int[] getData(){

        Random random = new Random(System.currentTimeMillis());
        for(int i=0;i<length;i++){
            data[i]=random.nextInt(2*length);
        }
        return data;
    }

}

結果是OK的

上面是按自己的構思開啟的執行緒。

其實Java本身提供了更好的解決方案，就是Fork/Join框架， 貼一下這個框架的介紹

使用Fork/Join 我們需要知道兩個類：

  • ForkJoinTask：我們要使用ForkJoin框架，必須首先建立一個ForkJoin任務。它提供在任務中執行fork()和join()操作的機制，通常情況下我們不需要直接繼承ForkJoinTask類，而只需要繼承它的子類，Fork/Join框架提供了以下兩個子類：
    • RecursiveAction：用於沒有返回結果的任務。
    • RecursiveTask ：用於有返回結果的任務。
  • ForkJoinPool ：ForkJoinTask需要通過ForkJoinPool來執行，任務分割出的子任務會新增到當前工作執行緒所維護的雙端佇列中，進入佇列的頭部。當一個工作執行緒的佇列裡暫時沒有任務時，它會隨機從其他工作執行緒的佇列的尾部獲取一個任務。

下面看下如何用這個框架實現多執行緒歸併排序

import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;
import java.util.concurrent.RecursiveTask;
import java.util.concurrent.TimeUnit;

public class Main {
    public static void main (String[] args) throws InterruptedException {
        int length = 1000;
        int[] data = (new Data(length)).getData();
        printArr(data);
        System.out.println();
        // mergeSort(data);
        //在這裡修改
        // int center = data.length/2;

        int[] tmp = new int[data.length];
        // CountDownLatch latch = new CountDownLatch(2);//CountDownLatch能夠使一個執行緒在等待另外一些執行緒完成各自工作之後，再繼續執行
        // new Thread(new Runnable(){
        
        //     @Override
        //     public void run() {
        //         mergeSort(data,tmp,0,center);
        //         latch.countDown();
        //     }
        // }).start();

        // new Thread(new Runnable(){
        
        //     @Override
        //     public void run() {
        //         mergeSort(data,tmp,center+1,data.length-1);
        //         latch.countDown();
        //     }
        // }).start();

        // latch.await();

        // merge(data, tmp, 0, center+1, data.length-1);

        //Fork/Join 從這裡開始
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        Main.mergeTask task = new Main.mergeTask(data, tmp, 0, data.length-1);//建立任務
        forkJoinPool.execute(task);//執行任務
        forkJoinPool.awaitTermination(2, TimeUnit.SECONDS);//阻塞當前執行緒直到pool中的任務都完成了

        printArr(data);
        System.out.println();
        verify(data);

    }

    //遞迴
    private static void mergeSort(int[] nums,int[] tmp,int left,int right){
        if(left<right){
            int center = (left+right)/2;
            mergeSort(nums,tmp,left,center);
            mergeSort(nums,tmp,center+1,right);
            merge(nums,tmp,left,center+1,right);
        }
    }

    //合併
    private static void merge(int[] nums,int[] tmp,int leftPos, int rightPos, int rightEnd){
        int leftEnd = rightPos-1;
        int tmpPos = leftPos;
        int numElements = rightEnd - leftPos + 1;
    
        while(leftPos<=leftEnd&&rightPos<=rightEnd){
            if(nums[leftPos]<nums[rightPos])
                tmp[tmpPos++]=nums[leftPos++];
            else 
                tmp[tmpPos++]=nums[rightPos++];
        }
        while(leftPos<=leftEnd)
            tmp[tmpPos++]=nums[leftPos++];
        
        while(rightPos<=rightEnd)
            tmp[tmpPos++]=nums[rightPos++];
    
        for(int i = 0;i<numElements;i++,rightEnd--)
            nums[rightEnd]=tmp[rightEnd];
    }
    public static void mergeSort(int[] nums){
        int[] tmp = new int[nums.length];
        mergeSort(nums,tmp,0,nums.length-1);
    }
    
    //列印
    public static void printArr(int[] arr) {
        for(int i : arr){
            System.out.print(i+" ");
        }
    }
    
    public static void verify(int[] nums) {
        for(int i=0;i<nums.length-1;i++){
            if(nums[i]>nums[i+1]){
                System.out.println("排序失敗");
                return;
            } 

        }
        System.out.println("排序成功");
    }
    

    static class mergeTask extends RecursiveAction {
        private static final int THRESHOLD = 2;//設定任務大小閾值
        private int start;
        private int end;
        private int[] data;
        private int[] tmp;
    
        public mergeTask(int[] data, int[] tmp, int start, int end){
            this.data = data;
            this.tmp = tmp;
            this.start = start;
            this.end = end;
        }
    
        @Override
        protected void compute(){
            if((end - start)<=THRESHOLD){
                mergeSort(data,tmp,start,end);
            }else{
                int center = (start + end)/2;
                Main.mergeTask leftTask = new Main.mergeTask(data, tmp, start, center);
                Main.mergeTask rightTask = new Main.mergeTask(data, tmp, center+1, end);

                leftTask.fork();
                rightTask.fork();

                leftTask.join();
                rightTask.join();

                merge(data, tmp, start, center+1, end);

            }
        }
    }

}


/**
 * 產生隨機資料
 */
class Data{
    int length;
    int[] data;

    public Data(int length){
        this.length = length;
        data = new int[length];
    }

    public int[] getData(){

        Random random = new Random(System.currentTimeMillis());
        for(int i=0;i<length;i++){
            data[i]=random.nextInt(2*length);
        }
        return data;
    }

}

結果也是OK的

以上都沒有涉及到鎖，雖然操作的是共享的陣列，但是被讀寫的區域是被隔離開的。

也是在演算法導論上瞟到多執行緒演算法這麼一章，順藤摸瓜才知道有Fork/Join 這個東西，要學的東西真的多。

搞完這個我又聯想到之前看過的一道演算法題：

在大量的資料中，尋找最大的k個數，或者是出現次數最多的k個數據，比如說這個資料有10個G，放在一個大檔案中，電腦記憶體4G。

解題思路就是先把這個檔案分塊，為了確保相同的資料在一個塊中，通過計算Hash值來分塊，相同Hash 放到一個塊中。比如每分100個塊，這樣平均一個塊就在100M左右，對每個塊分別載入記憶體找最大的前K個數或者出現最多的前K個數據，最後比較這100*K個數據來得到結果。

怎麼用多執行緒求解？

相關推薦

如何用多執行緒實現歸併排序

等我有時間了，一定要把《演算法導論》啃完，這本書的印刷質量實在太好了，滑稽。 之前聽吳恩達老大說過Python裡面的Numpy包的矩陣運算就是多執行緒的，所以能做到的情況下儘量用矩陣運算代替迴圈，這樣能大大加快運算的速度。 為了提高速度，如果不涉及外部資源讀取的話，要提高

用多執行緒實現多使用者同時收發的簡單socket服務端

簡單的socket程式碼和多執行緒練習用socket服務端和多執行緒實現可以連線多個客戶端並同時收發的功能。這裡要用到socket 和 threading所以，記得：import socket, threading一、建立socket服務端首先，按正常操作，建立一個socke

Java多執行緒--三個執行緒分別列印a,b,c.請用多執行緒實現迴圈列印15次abc

掃盲: 想想自己多執行緒解決生產消費者問題就知道個synchronized,真是慚愧 為做此題目特意學習新的多執行緒知識–ReentrantLock跟synchronized一樣都是Java中的可重入鎖(可以在內部鎖中拿到外部鎖) Con

C++：多執行緒程式設計學習:利用多執行緒進行歸併排序。

首先學習一下簡單的執行緒知識 ：(1)pthread_join函式,用來阻塞當前的執行緒。直到指定執行緒結束。 ：(2)pthread_create,用來建立執行緒。 下面的程式碼開了五個執行緒用來輸出一個函式。 #include <pth

Java用多執行緒實現賣票

    Java小白一個，剛開始學習執行緒，在這個過程中遇到了一些麻煩，經過2天的努力，終於弄懂了用多執行緒實現賣票的程式，嗯嗯，記錄一下！public class TicketImpDemo { public static void main(String[] args)

linux下用多執行緒實現socket伺服器和客戶端的非同步通訊

前面介紹了用select函式來實現socket的非同步收發資料，但是select函式也有一些缺陷，要使socket能持續地通訊，select必須不停地檢測，這樣程序就會一直阻塞在這裡，限制了功能的擴充套件，這裡我們用多執行緒的方式，另建立兩個執行緒用來發送/接收

linux網路程式設計之用多執行緒實現客戶端到服務端的通訊（基於udp）

1、開啟一個執行緒接受資料，主執行緒傳送資料的程式碼 #include <unistd.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #includ

【OS大作業】用多執行緒統計txt檔案中字元個數（Java實現）

問題描述 給定一個txt檔案，利用不同個數的執行緒查詢檔案中某字元的個數，探究執行緒個數與查詢時間的關係。 本作業程式碼使用JAVA實現，版本為10.0.2，使用的IDE為Eclipse4.9.0. 結果測試所用的txt檔案內容為英文，編碼格式為UTF-8。 原始碼 第一版程式碼：（

用java多執行緒實現一個簡單的水池進出水問題

需求： 有一個水池100L，有出水口和入水口,出水口和入水口不能同時開啟，入水口每次注入5L水，出水口每次出4L水，如果池子注滿水，或者池子中沒有水就停止。 使用繼承Thread類的方式編寫出水口，使用實現Runnable方式編寫入水口，執行結果。 package po

用java多執行緒實現“百度翻譯介面API快速翻譯”

不知道為啥，突然開始想寫部落格，可能是想找個地方寫點東西，煽情文藝的咱寫不了，就寫技術貼好了。不當之處，還希望同志們多多指教，不勝感激。 API準備：自己先到百度去申請一個百度翻譯API，話說百度翻譯還是可以的，每個月200W字元的免費翻譯，不做商業的基本夠用了，感謝百

Java多執行緒實現電影院售票案例

某電影院目前正在上映賀歲大片，共有100張票，而它有3個售票視窗，請設計一個程式模擬該電影院售票。 定義Sell類實現Runnable介面，很好的解決了單繼承共享資源問題 public class Sell implements Runnable { // 定義100張票，三個售票

Java 多執行緒實現死鎖場景

簡述： 《Java 程式設計思想》  P718 ~ P722 模擬死鎖的場景， 三個人 三根筷子，每個人需要拿到身邊的兩根筷子才能開始吃飯 出現死鎖的場景是，三個人都拿到了右邊的筷子，但是由於筷子都被搶佔，均無法獲得左邊的筷子 Chopstick.java

【Java筆記】多執行緒實現簡單的非同步運算

實現Callable介面，重寫call（）方法，使操作執行緒池時能帶有返回值的效果： import java.util.concurrent.Callable; public class GetSumCallable implements Callable<Integer> {

二、多執行緒實現簡單的socket通訊例項（TCP）

1.伺服器端 import java.io.*; import java.net.ServerSocket; import java.net.Socket; /** * 類功能描述：先啟動伺服器端，再啟動客戶端 * * @author：*** * @createTime：2018/

利用python多執行緒實現區塊鏈paxos演算法解決使用者共識

本來是做python 開發的老闆最近讓做區塊鏈也沒有頭緒從網上找了點視訊看著照的敲了了下感覺是自己寫過最多的程式碼啦 怪我才疏學淺  哈哈哈-- import threading, socket, pickle, queue class Message(object): MS

python 通過多執行緒實現Excel 批量更新商品價格

import openpyxl import threading wb = openpyxl.load_workbook('produceSales.xlsx') sheet = wb.active all_info = [] for row in sheet.rows: child

多執行緒實現UDP協議傳送、接收資料

  放碼過來吧！  public class ChatRoom { public static void main(String[] args) throws SocketException { DatagramSocket sendSocket =

MySQL 原始碼分析 Innodb緩衝池刷髒的多執行緒實現

簡介 為了提高效能，大多數的資料庫在操作資料時都不會直接讀寫磁碟，而是中間經過緩衝池，將要寫入磁碟的資料先寫入到緩衝池裡，然後在某個時刻後臺執行緒把修改的資料刷寫到磁碟上。MySQL的InnoDB引擎也使用緩衝池來快取從磁碟讀取或修改的資料頁，如果當前資料庫需要操作的資料集比緩衝池中的空閒頁面大

Python進階(二十六)-多執行緒實現同步的四種方式

分享一下我的偶像大神的人工智慧教程！http://blog.csdn.net/jiangjunshow 也歡迎轉載我的文章，轉載請註明出處 https://blog.csdn.net/mm2zzyzzp Python進階(二十六)-多執行緒實現同步的四種方式

Qt中採用多執行緒實現Socket程式設計

      本文介紹的是Qt中採用多執行緒Socket程式設計，由於工作專案的需要，使用Qt的socket程式設計。Qt裡的example是個不錯的教程，但是當我把程式碼移植