SUBANGKAR

Offline_Nov-11_Zahin

Nov 10th, 2016
131
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. import java.util.Scanner;
  2. import java.util.concurrent.ArrayBlockingQueue;
  3. import java.util.concurrent.BlockingQueue;
  4.  
  5. class resultStore {
  6.     WorkItem[] n;
  7.     boolean value = false;
  8. int size;
  9. int pos;
  10.     public resultStore(int size) {
  11.         this.size= size;
  12.         n= new WorkItem[size];
  13.         pos=-1;
  14.     }
  15.  
  16.     synchronized WorkItem get() {
  17.         if(pos<0) {
  18.             try {
  19.                 wait();
  20.             } catch (Exception e) {
  21.                 System.out.println("InterruptedException caught");
  22.             }
  23.         }
  24.       //  value = false;
  25.         notify();
  26.         return n[pos--];
  27.     }
  28.  
  29.     synchronized void put(WorkItem  m) {
  30.         if(pos==size) {
  31.             try {
  32.                 wait();
  33.             } catch (InterruptedException e) {
  34.                 System.out.println("InterruptedException caught");
  35.             }
  36.         }
  37.      
  38.         n[++pos] = m;
  39.         value = true;
  40.         notify();
  41.     }
  42. }
  43. class WorkItem{
  44.    public int[] row ;
  45.    public int[] column;
  46.    public int rowNum;
  47.    public int colNum;
  48.  
  49.    WorkItem(int[]a,int[]b,int i,int j){
  50.  
  51.       rowNum=i;
  52.       colNum=j;
  53.       int len=a.length;
  54.       row=new int[len];
  55.       column=new int[len];
  56.       for(int k=0;k<len;k++){
  57.          row[k] = a[k];
  58.       }
  59.       for(int x=0;x<len;x++){
  60.             column[x] = b[x];
  61.       }  
  62.     }
  63.      
  64. }
  65. class WorkerThread implements Runnable {
  66.  
  67.     resultStore p;
  68.     Thread t;
  69.     int r1;
  70.     int c1;
  71.     int r2;
  72.     int c2;
  73.     int noOfWorks;
  74.     int wh;
  75.     WorkItem [] obj1 ;
  76.     int [][] product;
  77.     WorkerThread(resultStore p,int noOfWorks,int r1,int c1,int r2,int c2,int[][]product,int wh) {
  78.         this.r1=r1;
  79.         this.r2=r2;
  80.         this.c1=c1;
  81.         this.c2=c2;
  82.         this.p = p;
  83.         obj1= new WorkItem[r1*r2];
  84.         this.noOfWorks=noOfWorks;
  85.         this.product=product;
  86.         this.wh=wh;
  87.         t=new Thread(this, "WorkerThread");
  88.         t.start();
  89.     }
  90.  
  91.     public void run() {
  92.         try {
  93.             int i=0;
  94.            
  95.             while (i<noOfWorks) {
  96.               //  System.out.println(wh+" runs for "+i+" times");
  97.                 int sum=0;
  98.                 obj1[i]=p.get();
  99.                 for(int j=0;j<c1;j++){
  100.                       sum+=(obj1[i].row[j] * obj1[i].column[j]);
  101.                    
  102.                 }
  103.                 product[obj1[i].rowNum-1][obj1[i].colNum-1] = sum;
  104.                // p.put(sum);
  105.                 i++;
  106.             }    
  107.             notify();
  108.         } catch(Exception e) {
  109.            
  110.         }
  111.     }
  112.        
  113.    
  114. }
  115.  
  116. public class Main {
  117.  
  118.  
  119.    
  120.    
  121.     public static void main(String[] args) throws InterruptedException {
  122.         Scanner in=new Scanner(System.in);
  123.         System.out.println("Enter no.of worker threads to be created: ");
  124.         int W=in.nextInt();
  125.         System.out.println("Enter row and column of first matrix:");
  126.         int row1=in.nextInt();
  127.         int col1=in.nextInt();
  128.        
  129.         int[][] matrix1=new int[row1][col1];
  130.         System.out.println("Enter first matrix:");
  131.         for(int j=0;j<row1;j++){
  132.            for(int i=0;i<col1;i++){
  133.                matrix1[j][i]=in.nextInt();        
  134.             }
  135.         }
  136.         System.out.println("Enter row and column of second matrix:");
  137.         int row2=in.nextInt();
  138.         int col2=in.nextInt();
  139.         int[][] matrix2=new int[row2][col2];
  140.         System.out.println("Enter second matrix:");
  141.        
  142.         for(int j=0;j<row2;j++){
  143.             for(int i=0;i<col2;i++){
  144.                 matrix2[j][i]=in.nextInt();        
  145.             }
  146.         }
  147.        
  148.         int [][] matrix2t=new int[col2][row2];
  149.         for(int i=0;i<col2;i++){
  150.             for(int j=0;j<row2;j++){
  151.              
  152.               matrix2t[i][j] = matrix2[j][i];
  153.              
  154.             }
  155.         }
  156.         int t= row2;
  157.         row2=col2;
  158.         col2=t;
  159.         int k=(row1*row2)/W;
  160.        int[][] resultArray = new int [row1][row2];
  161.         resultStore p = new resultStore(row1*row2);
  162.         WorkerThread[] b = new WorkerThread[W];
  163.        
  164.        
  165.         WorkItem [] obj = new WorkItem[row1*row2];
  166.         int i = 0;
  167.         for(int j=0;j<row1;j++){
  168.            for(int f=0;f<row2;f++){
  169.                obj[i] = new WorkItem(matrix1[j],matrix2t[f],j+1,f+1);
  170.                 i++;
  171.             }
  172.         }
  173.        
  174.         i=0;
  175.          
  176.          for(int var=0;var<W;var++){
  177.             b[var]= new WorkerThread(p,k,row1,col1,row2,col2,resultArray,var);
  178.         }
  179.         try {
  180.             while (i<row1*row2) {
  181.                 p.put(obj[i]);
  182.                 i++;
  183.             }
  184.        
  185.            } catch(Exception e) {
  186.            
  187.            
  188.         }
  189.  
  190.        try{
  191.              for(int var=0;var<W;var++){
  192.                 b[var].t.join();
  193.         }
  194.         }catch(InterruptedException e){
  195.            
  196.         }
  197.            System.out.println("Resultant matrix: ");
  198.             for(int m=0;m<row1;m++){
  199.                 for (int n = 0; n < row2; n++) {
  200.                     System.out.print(resultArray[m][n] + " ");
  201.                 }
  202.                 System.out.println(" ");
  203.             }
  204.         int[][] productMatrix=new int[row1][row2];
  205.         System.out.println("Resultant matrix using single thread: ");
  206.        for (int var3 =0 ; var3< row1; var3++ ) {  
  207.            for ( int var4 = 0; var4< row2; var4++ ) {    
  208.                int sum = 0;
  209.              for ( int var5 = 0; var5 < col1; var5++ ) {    
  210.                   sum += (matrix1[var3][var5] * matrix2t[var4][var5]);
  211.               }
  212.              productMatrix[var3][var4] = sum;
  213.             }
  214.         }
  215.  
  216.         for (int var1 =0 ; var1< row1; var1++ ) {  
  217.           for ( int var2 = 0; var2 < row2; var2++ ) {      
  218.                System.out.print(productMatrix[var1][var2]+" ");
  219.             }
  220.            System.out.println(" ");
  221.            
  222.         }
  223.  
  224.     }
  225. }
RAW Paste Data