Offline_Nov-11_Zahin

import java.util.Scanner;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

class resultStore {
    WorkItem[] n;
    boolean value = false;
int size;
int pos;
    public resultStore(int size) {
        this.size= size;
        n= new WorkItem[size];
        pos=-1;
    }

    synchronized WorkItem get() {
        if(pos<0) {
            try {
                wait();
            } catch (Exception e) {
                System.out.println("InterruptedException caught");
            }
        }
      //  value = false;
        notify();
        return n[pos--];
    }

    synchronized void put(WorkItem  m) {
        if(pos==size) {
            try {
                wait();
            } catch (InterruptedException e) {
                System.out.println("InterruptedException caught");
            }
        }

        n[++pos] = m;
        value = true;
        notify();
    }
}
class WorkItem{
   public int[] row ;
   public int[] column;
   public int rowNum;
   public int colNum;

   WorkItem(int[]a,int[]b,int i,int j){

      rowNum=i;
      colNum=j;
      int len=a.length;
      row=new int[len];
      column=new int[len];
      for(int k=0;k<len;k++){
         row[k] = a[k];
      }
      for(int x=0;x<len;x++){
            column[x] = b[x];
      }
    }

}
class WorkerThread implements Runnable {

    resultStore p;
    Thread t;
    int r1;
    int c1;
    int r2;
    int c2;
    int noOfWorks;
    int wh;
    WorkItem [] obj1 ;
    int [][] product;
    WorkerThread(resultStore p,int noOfWorks,int r1,int c1,int r2,int c2,int[][]product,int wh) {
        this.r1=r1;
        this.r2=r2;
        this.c1=c1;
        this.c2=c2;
        this.p = p;
        obj1= new WorkItem[r1*r2];
        this.noOfWorks=noOfWorks;
        this.product=product;
        this.wh=wh;
        t=new Thread(this, "WorkerThread");
        t.start();
    }

    public void run() {
        try {
            int i=0;

            while (i<noOfWorks) {
              //  System.out.println(wh+" runs for "+i+" times");
                int sum=0;
                obj1[i]=p.get();
                for(int j=0;j<c1;j++){
                      sum+=(obj1[i].row[j] * obj1[i].column[j]);

                }
                product[obj1[i].rowNum-1][obj1[i].colNum-1] = sum;
               // p.put(sum);
                i++;
            }
            notify();
        } catch(Exception e) {

        }
    }


}

public class Main {




    public static void main(String[] args) throws InterruptedException {
        Scanner in=new Scanner(System.in);
        System.out.println("Enter no.of worker threads to be created: ");
        int W=in.nextInt();
        System.out.println("Enter row and column of first matrix:");
        int row1=in.nextInt();
        int col1=in.nextInt();

        int[][] matrix1=new int[row1][col1];
        System.out.println("Enter first matrix:");
        for(int j=0;j<row1;j++){
           for(int i=0;i<col1;i++){
               matrix1[j][i]=in.nextInt();
            }
        }
        System.out.println("Enter row and column of second matrix:");
        int row2=in.nextInt();
        int col2=in.nextInt();
        int[][] matrix2=new int[row2][col2];
        System.out.println("Enter second matrix:");

        for(int j=0;j<row2;j++){
            for(int i=0;i<col2;i++){
                matrix2[j][i]=in.nextInt();
            }
        }

        int [][] matrix2t=new int[col2][row2];
        for(int i=0;i<col2;i++){
            for(int j=0;j<row2;j++){

              matrix2t[i][j] = matrix2[j][i];

            }
        }
        int t= row2;
        row2=col2;
        col2=t;
        int k=(row1*row2)/W;
       int[][] resultArray = new int [row1][row2];
        resultStore p = new resultStore(row1*row2);
        WorkerThread[] b = new WorkerThread[W];


        WorkItem [] obj = new WorkItem[row1*row2];
        int i = 0;
        for(int j=0;j<row1;j++){
           for(int f=0;f<row2;f++){
               obj[i] = new WorkItem(matrix1[j],matrix2t[f],j+1,f+1);
                i++;
            }
        }

        i=0;

         for(int var=0;var<W;var++){
            b[var]= new WorkerThread(p,k,row1,col1,row2,col2,resultArray,var);
        }
        try {
            while (i<row1*row2) {
                p.put(obj[i]);
                i++;
            }

           } catch(Exception e) {


        }

       try{
             for(int var=0;var<W;var++){
                b[var].t.join();
        }
        }catch(InterruptedException e){

        }
           System.out.println("Resultant matrix: ");
            for(int m=0;m<row1;m++){
                for (int n = 0; n < row2; n++) {
                    System.out.print(resultArray[m][n] + " ");
                }
                System.out.println(" ");
            }
        int[][] productMatrix=new int[row1][row2];
        System.out.println("Resultant matrix using single thread: ");
       for (int var3 =0 ; var3< row1; var3++ ) {
           for ( int var4 = 0; var4< row2; var4++ ) {
               int sum = 0;
             for ( int var5 = 0; var5 < col1; var5++ ) {
                  sum += (matrix1[var3][var5] * matrix2t[var4][var5]);
              }
             productMatrix[var3][var4] = sum;
            }
        }

        for (int var1 =0 ; var1< row1; var1++ ) {
          for ( int var2 = 0; var2 < row2; var2++ ) {
               System.out.print(productMatrix[var1][var2]+" ");
            }
           System.out.println(" ");

        }

    }
}