Java實驗項目四——多線程矩陣相乘算法的設計

Program：多線程矩陣相乘算法的設計

 

Description：利用多線程實現矩陣相乘，因為各個線程的運算互不影響，

　　　　　　所以不用使用鎖，代碼如下：

 

thread.OperateMatrix類，實現矩陣運算

/*
 * Description:定義矩陣操作類
 * 
 * Written By :Cai
 * 
 * Date Written:2017-10-25
 * 
 * */

package thread;

public class OperateMatrix {

    int[][] matrix1 = null;        //第一個矩陣
    int[][] matrix2 = null;        //第二個矩陣
    int[][] result = null;        //存放矩陣相乘結果
    public static int line = 0;    //記錄當前參與計算的是第一個矩陣的第幾行
    
    //定義構造方法
    public OperateMatrix() {}
    
    public OperateMatrix(int[][] m1,int[][] m2) {
        
        this.matrix1 = m1;
        this.matrix2 = m2;
        result = new int[matrix1.length][matrix2[0].length];
    }
    
    //返回矩陣相乘的結果
    public int[][] getResult() {
        
        try {
            
            /*
             * 當矩陣還沒有完全計算完時
             * 令當前線程睡眠1毫秒等待
             * 然后再次判斷
             * 
             * */
            while( OperateMatrix.line < matrix1.length ) {
                
                Thread.sleep(1);
                
            }
        }catch(Exception e) {
            
            e.printStackTrace();
        }
        
        return this.result;
        
    }
    
    //第一個矩陣的行乘以第二個矩陣的列，得到新矩陣的行
    public void operate() {
        
        OperateMatrix.line += 1;            //記錄行數加1
        
        for( int i = 0; i < matrix1[0].length; i++ ) {
            
            int sum = 0;        //存儲第一個矩陣的行和 第二個矩陣的列的計算結果
            for( int j = 0; j < matrix2.length; j++ ) {
                
                sum += matrix1[OperateMatrix.line - 1][j] * matrix2[j][i];        //第一個矩陣的當前行乘以第二個矩陣
            }
            
            result[OperateMatrix.line - 1][i] = sum;        //保存結果
        }
    
    }
}

 

thread.ThreadOperate類，線程實現類

 

/*
 * Description:定義類，繼承Thread類，覆寫run()方法
 * 
 * Written By:Cai
 * 
 * Date Written:2017-10-25
 * 
 * */

package thread;

public class ThreadOperate extends Thread {

    private OperateMatrix om = null;        //定義矩陣操類對象
    
    //定義構造方法
    public ThreadOperate() {
        super();
    }
    
    public ThreadOperate( OperateMatrix om,String name) {
        super(name);        //線程名字
        this.om = om;
    }
    
    //覆寫run()方法
    @Override
    public void run() {
        
        try {
            System.out.println( Thread.currentThread().getName() );        //打印當前線程的名字
        }catch( Exception e ) {
            e.printStackTrace();
        }
        
        /*
         * 調用OperateMatrix對象的operate方法，進行矩陣的計算
         * 每次調用只計算一行結果
         * 
         * */
        this.om.operate();        
    }
    
}

 

 

main.TestDemo測試類

 

/*
 * Description:定義測試類
 * 
 * Written By :Cai
 * 
 * Date Written:2017-10-25
 * 
 * */


package main;


import thread.*;

public class TestDemo {

    public static void main(String args[]) {
        
        //定義兩個矩陣
        int[][] m1 = {{1,4,1,1},{4,1,1,1},{1,3,3,6},{1,6,9,0}};        //4*4
        int[][] m2 = {{2,2,2,2},{2,2,2,2},{2,2,2,2},{2,2,2,2}};        //4*4
        
        OperateMatrix om = new OperateMatrix(m1,m2);                //實例化OperateMatrix對象
        
        //根據第一個矩陣的行數，啟動對應數量的線程
        for( int i = 0; i < m1.length; i++ ) {
            
            new ThreadOperate( om,"計算第一個矩陣的第" + (i+1) + "行*第二個矩陣的所有列" ).start();
        }
        

        display(om.getResult());    //打印結果
        
    }
    
    
    //打印計算結果（為了方便，將打印方法定義在測試類中，實際不應該這樣做）
    public static void display(int[][] result) {
        
        for( int i = 0; i < result.length; i++ ) {
            
            for( int j = 0; j < result[i].length; j++ ) {
                
                System.out.print( result[i][i] + "\t" );
            }
            
            System.out.println();
        }
    }
    
}