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] + "	" );
            }
            
            System.out.println();
        }
    }
    
}