/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package srtrs_v25;

import java.util.Arrays;
import java.util.Random;
import java.util.concurrent.Exchanger;

/**
 * Created by ljuba on 11.11.14.
 */
class Data {

    public int MA[][];
    public int MB[][];
    public int MC[][];

    public Data(int[][] MA, int[][] MB, int[][] MC) {
        this.MA = MA;
        this.MB = MB;
        this.MC = MC;
    }
}

public class srTRS_l25 {

    public static int size = 5;

    static class Thread3 extends Thread {

        public int MA[][];
        public int MB[][];
        public int MC[][];
        Exchanger<Data> exchanger1;
        Exchanger<Data> exchanger2;

        public Thread3(Exchanger<Data> exchanger1, Exchanger<Data> exchanger2) {
            this.exchanger1 = exchanger1;
            this.exchanger2 = exchanger2;
        }

        @Override
        public void run() {
            MA = new int[size][size];
            try {
                MA = new int[size][size];
                Data d = exchanger1.exchange(new Data(null, null, null));
                MB = d.MB;
                MC = d.MC;
                exchanger2.exchange(new Data(null, MB, MC));
                for (int i = 4; i < 5; i++) {
                    for (int j = 0; j < size; j++) {
                        for (int k = 0; k < size; k++) {
                            MA[i][j] += MB[i][k] * MC[k][j];
                        }
                    }
                }
                System.out.println("Thread3: " + Arrays.toString(MA[4]));
                d = exchanger1.exchange(new Data(null, null, null));
                for (int i =  4; i < size; i++) {
                    for (int j = 0; j < size; j++) {
                        d.MA[i][j] = MA[i][j];
                    }
                }
                for (int i = 0; i < size; i++) {
                    System.out.println(Arrays.toString(d.MA[i]));
                }
            } catch (InterruptedException e) {
                //**
            }
        }
    }

    static class Thread4 extends Thread {

        public int MA[][];
        public int MB[][];
        public int MC[][];
        Exchanger<Data> exchanger1;
        Exchanger<Data> exchanger2;

        public Thread4(Exchanger<Data> exchanger1, Exchanger<Data> exchanger2) {
            this.exchanger1 = exchanger1;
            this.exchanger2 = exchanger2;
        }

        @Override
        public void run() {
            MA = new int[size][size];
            MB = new int[size][size];
            MC = new int[size][size];
            System.out.println("MB:");
            for (int i = 0; i < size; i++) {
                for (int j = 0; j < size; j++) {
                    MB[i][j] = i + 1;

                }
                System.out.println(Arrays.toString(MB[i]));
            }
            try {
                MA = new int[size][size];
                Data d = exchanger1.exchange(new Data(null, MB, null));
                MC = d.MC;
                exchanger2.exchange(new Data(null, MB, MC));
                for (int i = 2; i < 3; i++) {
                    for (int j = 0; j < size; j++) {
                        for (int k = 0; k < size; k++) {
                            MA[i][j] += MB[i][k] * MC[k][j];
                        }
                    }
                }
                System.out.println("Thread4: " + Arrays.toString(MA[2]));
                d = exchanger1.exchange(new Data(null, null, null));
                for (int i = 0; i < 2; i++) {
                    for (int j = 0; j < size; j++) {
                        MA[i][j] = d.MA[i][j];
                    }
                }
                for (int i = 3; i < size; i++) {
                    for (int j = 0; j < size; j++) {
                        MA[i][j] = d.MA[i][j];
                    }
                }
                exchanger2.exchange(new Data(MA, null, null));
            } catch (InterruptedException e) {
                //**
            }
        }
    }

    static class Thread5 extends Thread {

        public int MA[][];
        public int MB[][];
        public int MC[][];
        Exchanger<Data> exchanger1;
        Exchanger<Data> exchanger2;

        public Thread5(Exchanger<Data> exchanger1, Exchanger<Data> exchanger2) {
            this.exchanger1 = exchanger1;
            this.exchanger2 = exchanger2;
        }

        @Override
        public void run() {
            MA = new int[size][size];
            MB = new int[size][size];
            MC = new int[size][size];
            System.out.println("MC:");
            Random rand = new Random();
            for (int i = 0; i < size; i++) {
                for (int j = 0; j < size; j++) {
                    MC[i][j] = 2;//rand.nextInt(3)+1;
                }
                System.out.println(Arrays.toString(MC[i]));
            }
            try {

                Data d = exchanger1.exchange(new Data(null, null, MC));
                MB = d.MB;
                exchanger2.exchange(new Data(null, MB, MC));
                for (int i = 3; i < 4; i++) {
                    for (int j = 0; j < size; j++) {
                        for (int k = 0; k < size; k++) {
                            MA[i][j] += MB[i][k] * MC[k][j];
                        }
                    }
                }
                System.out.println("Thread5: " + Arrays.toString(MA[3]));
                d = exchanger2.exchange(new Data(null, null, null));
                for (int i = 3; i < size; i++) {
                    for (int j = 0; j < size; j++) {
                        d.MA[i][j] = MA[i][j];
                    }
                }
                exchanger1.exchange(d);

            } catch (InterruptedException e) {
                //**
            }
        }
    }

    static class Thread2 extends Thread {

        public int MA[][];
        public int MB[][];
        public int MC[][];
        Exchanger<Data> exchanger1;
        Exchanger<Data> exchanger2;
        Exchanger<Data> exchanger3;

        public Thread2(Exchanger<Data> exchanger1, Exchanger<Data> exchanger2, Exchanger<Data> exchanger3) {
            this.exchanger1 = exchanger1;
            this.exchanger2 = exchanger2;
            this.exchanger3 = exchanger3;
        }

        @Override
        public void run() {
            try {
                MA = new int[size][size];
                Data d = exchanger1.exchange(new Data(null, null, null));
                MC = d.MC;
                d = exchanger3.exchange(new Data(null, null, null));
                MB = d.MB;
                exchanger2.exchange(d);
                for (int i = 0; i < 1; i++) {
                    for (int j = 0; j < size; j++) {
                        for (int k = 0; k < size; k++) {
                            MA[i][j] += MB[i][k] * MC[k][j];
                        }
                    }
                }
                System.out.println("Thread2: " + Arrays.toString(MA[0]));
                exchanger2.exchange(new Data(MA, null, null));
                d = exchanger2.exchange(new Data(null, null, null));
                exchanger1.exchange(d);

            } catch (InterruptedException e) {
                //**
            }
        }
    }

    static class Thread1 extends Thread {

        public int MA[][];
        public int MB[][];
        public int MC[][];
        Exchanger<Data> exchanger1;

        public Thread1(Exchanger<Data> exchanger1) {
            this.exchanger1 = exchanger1;
        }

        @Override
        public void run() {
            try {
                MA = new int[size][size];
                Data d = exchanger1.exchange(new Data(null, null, null));
                MB = d.MB;
                MC = d.MC;
                for (int i = 1; i < 2; i++) {
                    for (int j = 0; j < size; j++) {
                        for (int k = 0; k < size; k++) {
                            MA[i][j] += MB[i][k] * MC[k][j];
                        }
                    }
                }
                System.out.println("Thread1: " + Arrays.toString(MA[1]));
                d = exchanger1.exchange(new Data(null, null, null));
                for (int i = 0; i < 1; i++) {
                    for (int j = 0; j < size; j++) {
                        MA[i][j] = d.MA[i][j];
                    }
                }
                exchanger1.exchange(new Data(MA, null, null));
            } catch (InterruptedException e) {
                //--
            }
        }
    }

    public static void main(String[] args) {
        Exchanger<Data> e1 = new Exchanger<Data>();
        Exchanger<Data> e2 = new Exchanger<Data>();
        Exchanger<Data> e3 = new Exchanger<Data>();
        Exchanger<Data> e4 = new Exchanger<Data>();
        Exchanger<Data> e5 = new Exchanger<Data>();

        new Thread1(e5).start();
        new Thread2(e3, e5, e4).start();
        new Thread3(e2, e4).start();
        new Thread4(e1,e2).start();
        new Thread5(e1,e3).start();
    }
}