Java实验项目四——多线程矩阵相乘算法的设计

Posted 2020-10-12 Pretty Boy

Program：多线程矩阵相乘算法的设计

 

Description：利用多线程实现矩阵相乘，因为各个线程的运算互不影响，

　　　　　　所以不用使用锁，代码如下：

 

thread.OperateMatrix类，实现矩阵运算

 1 /*
 2  * Description:定义矩阵操作类
 3  * 
 4  * Written By :Cai
 5  * 
 6  * Date Written:2017-10-25
 7  * 
 8  * */
 9 
10 package thread;
11 
12 public class OperateMatrix {
13 
14     int[][] matrix1 = null;        //第一个矩阵
15     int[][] matrix2 = null;        //第二个矩阵
16     int[][] result = null;        //存放矩阵相乘结果
17     public static int line = 0;    //记录当前参与计算的是第一个矩阵的第几行
18     
19     //定义构造方法
20     public OperateMatrix() {}
21     
22     public OperateMatrix(int[][] m1,int[][] m2) {
23         
24         this.matrix1 = m1;
25         this.matrix2 = m2;
26         result = new int[matrix1.length][matrix2[0].length];
27     }
28     
29     //返回矩阵相乘的结果
30     public int[][] getResult() {
31         
32         try {
33             
34             /*
35              * 当矩阵还没有完全计算完时
36              * 令当前线程睡眠1毫秒等待
37              * 然后再次判断
38              * 
39              * */
40             while( OperateMatrix.line < matrix1.length ) {
41                 
42                 Thread.sleep(1);
43                 
44             }
45         }catch(Exception e) {
46             
47             e.printStackTrace();
48         }
49         
50         return this.result;
51         
52     }
53     
54     //第一个矩阵的行乘以第二个矩阵的列，得到新矩阵的行
55     public void operate() {
56         
57         OperateMatrix.line += 1;            //记录行数加1
58         
59         for( int i = 0; i < matrix1[0].length; i++ ) {
60             
61             int sum = 0;        //存储第一个矩阵的行和 第二个矩阵的列的计算结果
62             for( int j = 0; j < matrix2.length; j++ ) {
63                 
64                 sum += matrix1[OperateMatrix.line - 1][j] * matrix2[j][i];        //第一个矩阵的当前行乘以第二个矩阵
65             }
66             
67             result[OperateMatrix.line - 1][i] = sum;        //保存结果
68         }
69     
70     }
71 }

 

thread.ThreadOperate类，线程实现类

 

 1 /*
 2  * Description:定义类，继承Thread类，覆写run()方法
 3  * 
 4  * Written By:Cai
 5  * 
 6  * Date Written:2017-10-25
 7  * 
 8  * */
 9 
10 package thread;
11 
12 public class ThreadOperate extends Thread {
13 
14     private OperateMatrix om = null;        //定义矩阵操类对象
15     
16     //定义构造方法
17     public ThreadOperate() {
18         super();
19     }
20     
21     public ThreadOperate( OperateMatrix om,String name) {
22         super(name);        //线程名字
23         this.om = om;
24     }
25     
26     //覆写run()方法
27     @Override
28     public void run() {
29         
30         try {
31             System.out.println( Thread.currentThread().getName() );        //打印当前线程的名字
32         }catch( Exception e ) {
33             e.printStackTrace();
34         }
35         
36         /*
37          * 调用OperateMatrix对象的operate方法，进行矩阵的计算
38          * 每次调用只计算一行结果
39          * 
40          * */
41         this.om.operate();        
42     }
43     
44 }

 

 

main.TestDemo测试类

 

 1 /*
 2  * Description:定义测试类
 3  * 
 4  * Written By :Cai
 5  * 
 6  * Date Written:2017-10-25
 7  * 
 8  * */
 9 
10 
11 package main;
12 
13 
14 import thread.*;
15 
16 public class TestDemo {
17 
18     public static void main(String args[]) {
19         
20         //定义两个矩阵
21         int[][] m1 = {{1,4,1,1},{4,1,1,1},{1,3,3,6},{1,6,9,0}};        //4*4
22         int[][] m2 = {{2,2,2,2},{2,2,2,2},{2,2,2,2},{2,2,2,2}};        //4*4
23         
24         OperateMatrix om = new OperateMatrix(m1,m2);                //实例化OperateMatrix对象
25         
26         //根据第一个矩阵的行数，启动对应数量的线程
27         for( int i = 0; i < m1.length; i++ ) {
28             
29             new ThreadOperate( om,"计算第一个矩阵的第" + (i+1) + "行*第二个矩阵的所有列" ).start();
30         }
31         
32 
33         display(om.getResult());    //打印结果
34         
35     }
36     
37     
38     //打印计算结果（为了方便，将打印方法定义在测试类中，实际不应该这样做）
39     public static void display(int[][] result) {
40         
41         for( int i = 0; i < result.length; i++ ) {
42             
43             for( int j = 0; j < result[i].length; j++ ) {
44                 
45                 System.out.print( result[i][i] + "\t" );
46             }
47             
48             System.out.println();
49         }
50     }
51     
52 }