2. 程式人生 > 其它 >多執行緒入門之矩陣乘法

多執行緒入門之矩陣乘法

阿新 • • 發佈：2021-07-30

  • 問題：矩陣相乘一系列優化。下面我們以c[2000][2000] = a[2000][2000] * b[2000][2000] 為例來進行優化。

  • 環境：CPU intel 9600k 6核心6執行緒 3.7GHz

多執行緒

To optimize the performance of this program, we have to use the advantage of multi-cores. We will create a thread for each row in a matrix that does the multiplication in parellel and reduce the processing time.

Let us create a Thread class that implements Runnable Interface.

RowMultiplyWorker.class :

public class RowMultiplyWorker implements Runnable /* extends Thread */ {
    public RowMultiplyWorker(int[][] result, int[][] matrix1, int[][] matrix2, int row) {
        this.result = result;
        this.matrix1 = matrix1;
        this.matrix2 = matrix2;
        this.row = row;
    }

    @Override
    public void run() {
        for (int i = 0; i < matrix2[0].length; i++) {
            result[row][i] = 0;
            for (int j = 0; j < matrix1[row].length; j++) {
                result[row][i] += matrix1[row][j] * matrix2[j][i];
            }
        }
    }

    private int[][] matrix1;
    private int[][] matrix2;
    private final int[][] result;
    private final int row;
}

Next, create a class to create 10 threads at a time because if we create 2000 threads for 2000 x 2000 matrix then the application gets to hang up. So we will be using the 10 threads as a group and let them complete then again initiate the next 10 threads untill complete each row multiplication.

ParallelThreadCreator

:

import java.util.List;
import java.util.ArrayList;

public class ParallelThreadCreator {

    // creating 10 threads and waiting for them to complete then again repeat steps.
    public static void multiply(int[][] matrix1, int[][] matrix2, int[][] result) {
        List<Thread> threads = new ArrayList<>();
        int rows1 = matrix1.length;
        for (int i = 0; i < rows1; i++) {
            // 方式一：直接建立執行緒（RowMultiplyWorker implements Runnable）
            RowMultiplyWorker task = new RowMultiplyWorker(result, matrix1, matrix2, i);
            Thread thread = new Thread(task);
            thread.start();
            threads.add(thread);

//            // 方式二：以子類的方式建立執行緒（RowMultiplyWorker extends Thread）
//            Thread thread = new RowMultiplyWorker(result, matrix1, matrix2, i);
//            thread.start();
//            threads.add(thread);

            if (threads.size() % 10 == 0) {
                waitForThreads(threads);
            }
        }
    }

    private static void waitForThreads(List<Thread> threads) {
        for (Thread thread : threads) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        threads.clear();
    }
}

Let us create the main class to test the time taking using this approach.

import java.util.Random;

public class Main {
    public static void main(String[] args) {
        // 初始化a,b陣列
        init();

        // 無任何優化
        int t1 = get1();
        System.out.println("單執行緒序列：" + t1 + "毫秒，約" + t1 / 1000 + "秒");
        System.out.println("==================================================");

        // 利用 Cache：改變迴圈的巢狀順序
        int t2 = get2();
        System.out.println("單執行緒序列（利用 Cache：改變迴圈的巢狀順序）：" + t2 + "毫秒，約" + t2 / 1000 + "秒");
        // 檢查get2()計算的d陣列，結果是否正確
        if (check(c, d)) System.out.println("正確");
        else System.out.println("錯誤");
        System.out.println("==================================================");

        // 多執行緒
        long start = System.currentTimeMillis();
        ParallelThreadCreator.multiply(a, b, e);
        long end = System.currentTimeMillis();
        int t3 = (int) (end - start);
        System.out.println("多執行緒並行：" + t3 + "毫秒，約" + t3 / 1000 + "秒");
        // 檢查多執行緒計算的e陣列，結果是否正確
        if (check(c, e)) System.out.println("正確");
        else System.out.println("錯誤");
    }

    // 返回一次矩陣乘法運算所需時間（ms）
    private static int get1() {
        long start = System.currentTimeMillis();
        for (int i = 0; i < N; i++)
            for (int j = 0; j < N; j++)
                for (int k = 0; k < N; k++)
                    c[i][j] += a[i][k] * b[k][j];
        long end = System.currentTimeMillis();
        return (int) (end - start);
    }

    // 返回一次矩陣乘法運算所需時間（ms）無任何優化
    private static int get2() {
        long start = System.currentTimeMillis();
        for (int i = 0; i < N; i++)
            for (int k = 0; k < N; k++)
                for (int j = 0; j < N; j++)
                    d[i][j] += a[i][k] * b[k][j];
        long end = System.currentTimeMillis();
        return (int) (end - start);
    }

    private static void init() {
        // a，b矩陣賦值 [1, 100] 範圍內的隨機數
        for (int i = 0; i < N; i++)
            for (int j = 0; j < N; j++) {
                // 元素值為[1, 100]的隨機數
                a[i][j] = rd.nextInt(seed) + 1;
                b[i][j] = rd.nextInt(seed) + 1;
            }
    }

    private static boolean check(int[][] matrix1, int[][] matrix2) {
        for (int i = 0; i < N; i++)
            for (int j = 0; j < N; j++)
                if (matrix1[i][j] != matrix2[i][j])
                    return false;

        return true;
    }

    private static final int N = 2000, seed = 100;
    private static int[][] a = new int[N][N];
    private static int[][] b = new int[N][N];
    private static int[][] c = new int[N][N];   // 無任何優化計算的結果
    private static int[][] d = new int[N][N];   // 利用 Cache：改變迴圈的巢狀順序計算的結果
    private static int[][] e = new int[N][N];   // 多執行緒計算的結果
    private static Random rd = new Random();
}

In this article, we have seen how to build the concurrent application for Matrix Multiplication. Now compare the time taken for 2000 x 2000 sized matrix is 65 seconds in the normal program and when we applied the multiple threads then it took only 17 seconds to complete this.

Still we can improve parallel version using Runtime.getRuntime().availableProcessors(). This returns the threads available to use and this count can be instead of 10 threads.

So, It is better to use the multiple threads efficiently for large scale applications.

實驗結果

因為我們是把N行分組，然後把該組交由多執行緒計算，所以組內行數必須能整除N。否則最後會有幾行沒有計算。

  • 當我們設定矩陣維度N = 2000，組內行數（執行緒數量）設定為20時，結果如下：

    單執行緒序列：48698毫秒，約48秒
==================================================
單執行緒序列（利用 Cache：改變迴圈的巢狀順序）：5859毫秒，約5秒
正確
==================================================
多執行緒並行：8210毫秒，約8秒
正確

  • 當我們設定矩陣維度N = 2000，組內行數（執行緒數量）設定為10時，結果如下：

    單執行緒序列：48904毫秒，約48秒
==================================================
單執行緒序列（利用 Cache：改變迴圈的巢狀順序）：5864毫秒，約5秒
正確
==================================================
多執行緒並行：8887毫秒，約8秒
正確

  • 當我們設定矩陣維度N = 2000，組內行數（執行緒數量）設定為8時，結果如下：

    單執行緒序列：48263毫秒，約48秒
==================================================
單執行緒序列（利用 Cache：改變迴圈的巢狀順序）：5871毫秒，約5秒
正確
==================================================
多執行緒並行：8934毫秒，約8秒
正確

  • 當我們設定矩陣維度N = 2000，組內行數（執行緒數量）設定為4時，結果如下：

    單執行緒序列：49045毫秒，約49秒
==================================================
單執行緒序列（利用 Cache：改變迴圈的巢狀順序）：6003毫秒，約6秒
正確
==================================================
多執行緒並行：11993毫秒，約11秒
正確

  • 當我們設定矩陣維度N = 2000，組內行數設定為2時，結果如下：

    單執行緒序列：50119毫秒，約50秒
==================================================
單執行緒序列（利用 Cache：改變迴圈的巢狀順序）：5861毫秒，約5秒
正確
==================================================
多執行緒並行：24061毫秒，約24秒
正確

  • 當我們設定矩陣維度N = 2000，組內行數（執行緒數量）設定為1時，結果如下：

    單執行緒序列：51972毫秒，約51秒
==================================================
單執行緒序列（利用 Cache：改變迴圈的巢狀順序）：6111毫秒，約6秒
正確
==================================================
多執行緒並行：49762毫秒，約49秒
正確

我們可以發現設定過多（超過硬體本身執行緒規格）或過少（沒有充分利用硬體本身執行緒規格）的執行緒數都不合適，執行緒數量的設定應該與硬體提供的執行緒數相當。當然，我們也不能一味的盲目推崇多執行緒，而不注重程式的優化，這一點從 利用 Cache：改變迴圈的巢狀順序 資料就可以看出。它的用時更短，當然這也和我們硬體本身提供的執行緒數量有限有關，畢竟只有6執行緒。

Preference

相關推薦

多執行緒入門之矩陣乘法

問題：矩陣相乘一系列優化。下面我們以c[2000][2000] = a[2000][2000] * b[2000][2000] 為例來進行優化。

python多執行緒案例之多工copy檔案完整例項

本文例項講述了python多執行緒案例之多工copy檔案。分享給大家供大家參考，具體如下：

python多執行緒同步之檔案讀寫控制

本文例項為大家分享了python多執行緒同步之檔案讀寫控制的具體程式碼，供大家參考，具體內容如下

Python多執行緒操作之互斥鎖、遞迴鎖、訊號量、事件例項詳解

本文例項講述了Python多執行緒操作之互斥鎖、遞迴鎖、訊號量、事件。分享給大家供大家參考，具體如下：

多執行緒入門

1. 理解執行緒與程序 由於併發肯定涉及到多執行緒，因此在進入併發程式設計主題之前，我們先來了解一下程序和執行緒的由來，這對後面對併發程式設計的理解將會有很大的幫助。

再談多執行緒模型之生產者消費者（多生產者和單一消費者 ）（c++11實現）

1.多生產者&單一消費者 1.1 與 單一生產者和多消費者模型類似， 因為存在多個生產者，需要考慮生產者之間的互斥訪問; 消費者只有一個，因此不存在消費者之間的互斥與競爭。

再談多執行緒模型之生產者消費者（總結）（c++11實現）

0.關於 為縮短篇幅，本系列記錄如下： 再談多執行緒模型之生產者消費者（基礎概念）（c++11實現）

c++11多執行緒程式設計之std::async的介紹與例項

本節討論下在C++11中怎樣使用std::async來執行非同步task。 C++11中引入了std::async 什麼是std::async

多執行緒入門案例與java8的並行流

java8 例項請移步https://www.cnblogs.com/ngLee/p/14021859.html 程序與執行緒 程序是所有執行緒的集合，每一個執行緒是程序中的一條執行路徑。

Java 多執行緒入門

基本概念 程式 ：是指為完成特定任務 ，用某種程式語言編寫的一組指令的集合 ，一段靜態程式碼 。

Java多執行緒入門（20-12-08）

Process 與 Thread（20-12-08） 程序是執行程式的一次執行過程，它是一個動態的概念。是系統資源分配的單位

04C++11多執行緒程式設計之建立多個執行緒和資料共享問題分析

技術標籤：C++11多執行緒程式設計多執行緒 04C++11多執行緒程式設計之建立多個執行緒和資料共享問題分析

Java多執行緒優化之執行緒池的使用方法

技術標籤：開發相關技術java多執行緒併發程式設計 Java多執行緒優化之執行緒池

多執行緒程式設計之pthread_cond_signal和pthread_cond_wait

技術標籤：多執行緒多執行緒 在多執行緒程式設計中可能會碰到pthread_cond_signal和pthread_cond_wait使用不當而帶來的詭異問題。今天說下我碰到的問題及解決思路，希望能對遇到類似問題的朋友有所幫助。

多執行緒問題之按序列印

技術標籤：多執行緒 一、題目描述 我們提供了一個類： public class Foo { public void first() { print(“first”); } public void second() { print(“second”); } public void third() { print(“third”);

多執行緒實踐之物件池

多執行緒實踐 目錄整理自陳碩大大的 多執行緒網路程式設計 ，大佬真的牛物件池版本1：版本2 加入 weak_ptr版本3 加入定製的解構函式版本4 加入enable_shared_from_this版本5 弱回撥

多執行緒專題之4-Tread後臺執行緒和前臺執行緒

前臺執行緒 程式強制關掉後，執行緒也隨之消失了，不會往後執行 thead.IsBackground = true；

多執行緒專題之1-程序、執行緒、控制代碼介紹

程序 計算機概念，虛擬的記錄，描述一個應用程式在計算機執行的時候，所消耗的各種資源的集合-CPU內容+磁碟IO+網路資源。

多執行緒專題之3-ThreadAPI使用

1、執行緒暫停 thread.Suspend() 2、執行緒恢復執行 thread.Resume() 3、執行緒停止 thread.Abort()

C++多執行緒-chap1多執行緒入門7

這裡，只是記錄自己的學習筆記。 順便和大家分享多執行緒的基礎知識。然後從入門到實戰。有程式碼。