2019-10-07 02:49:29 +00:00
|
|
|
import java.lang.reflect.Array;
|
2019-10-07 02:38:37 +00:00
|
|
|
import java.util.Random;
|
2019-10-07 03:12:48 +00:00
|
|
|
import java.util.concurrent.BrokenBarrierException;
|
2019-10-07 02:49:29 +00:00
|
|
|
import java.util.concurrent.CyclicBarrier;
|
|
|
|
import java.util.ArrayList;
|
|
|
|
import java.util.concurrent.atomic.AtomicInteger;
|
2019-10-07 02:38:37 +00:00
|
|
|
|
|
|
|
public class Main {
|
2019-10-07 03:53:16 +00:00
|
|
|
static int SIZE = 40;
|
2019-10-07 02:38:37 +00:00
|
|
|
int [][] a;
|
|
|
|
int [][] b;
|
|
|
|
int [][] c;
|
|
|
|
int [][] d;
|
2019-10-07 02:49:29 +00:00
|
|
|
CyclicBarrier barrier;
|
|
|
|
ArrayList<Integer> workingOn;
|
2019-10-07 02:38:37 +00:00
|
|
|
|
|
|
|
public static void main(String[] args) {
|
|
|
|
var main = new Main();
|
|
|
|
main.execute();
|
|
|
|
}
|
|
|
|
|
|
|
|
void execute() {
|
|
|
|
var random = new Random();
|
|
|
|
a = new int[SIZE][SIZE];
|
|
|
|
b = new int[SIZE][SIZE];
|
|
|
|
c = new int[SIZE][SIZE];
|
|
|
|
d = new int[SIZE][SIZE];
|
2019-10-07 03:12:48 +00:00
|
|
|
barrier = new CyclicBarrier(SIZE);
|
2019-10-07 02:49:29 +00:00
|
|
|
workingOn = new ArrayList<>();
|
|
|
|
workingOn.add(0);
|
|
|
|
workingOn.add(0);
|
|
|
|
|
2019-10-07 02:38:37 +00:00
|
|
|
for (int row = 0; row < SIZE; row++) {
|
|
|
|
for (int col = 0; col < SIZE; col++) {
|
2019-10-07 03:53:16 +00:00
|
|
|
a[row][col] = random.nextInt(2);
|
2019-10-07 02:38:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
for (int row = 0; row < SIZE; row++) {
|
|
|
|
for (int col = 0; col < SIZE; col++) {
|
2019-10-07 03:53:16 +00:00
|
|
|
b[row][col] = random.nextInt(2);
|
2019-10-07 02:38:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
printMatrix(a, "A");
|
|
|
|
printMatrix(b, "B");
|
|
|
|
for (int row = 0; row < SIZE; row++) {
|
2019-10-07 02:49:29 +00:00
|
|
|
synchronized (workingOn) {
|
|
|
|
workingOn.set(0, workingOn.get(0) + 1);
|
|
|
|
System.out.println("Start thread " + row);
|
|
|
|
new Thread(new Worker(row)).start();
|
2019-10-07 03:53:16 +00:00
|
|
|
Thread.yield();
|
2019-10-07 02:38:37 +00:00
|
|
|
}
|
|
|
|
}
|
2019-10-07 02:49:29 +00:00
|
|
|
while (workingOn.get(0) + workingOn.get(1) != 0) {
|
|
|
|
synchronized (workingOn) {
|
2019-10-07 03:12:48 +00:00
|
|
|
Thread.yield();
|
2019-10-07 02:49:29 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
printMatrix(c, "C");
|
2019-10-07 02:38:37 +00:00
|
|
|
printMatrix(d, "D");
|
|
|
|
}
|
|
|
|
|
|
|
|
static int computeAtPosition(int[][] m1, int[][] m2, int row, int col) {
|
|
|
|
int product = 0;
|
|
|
|
for (int k = 0; k < SIZE; k++) {
|
|
|
|
product += m1[row][k] * m2[k][col];
|
|
|
|
}
|
|
|
|
return product;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void printMatrix(int[][] m1, String label) {
|
|
|
|
System.out.println(label);
|
|
|
|
for (int i = 0; i < SIZE; i++) {
|
|
|
|
for (int j = 0; j < SIZE; j++) {
|
|
|
|
System.out.print("" + m1[i][j] + "\t");
|
|
|
|
}
|
|
|
|
System.out.println();
|
|
|
|
}
|
|
|
|
}
|
2019-10-07 02:49:29 +00:00
|
|
|
|
|
|
|
class Worker implements Runnable {
|
|
|
|
int row;
|
|
|
|
public Worker(int row) { this.row = row; }
|
|
|
|
public void run() {
|
|
|
|
for (int col = 0; col < SIZE; col++) {
|
|
|
|
c[row][col] = computeAtPosition(a, b, row, col);
|
2019-10-07 03:12:48 +00:00
|
|
|
Thread.yield();
|
2019-10-07 02:49:29 +00:00
|
|
|
}
|
|
|
|
synchronized (workingOn) {
|
2019-10-07 03:12:48 +00:00
|
|
|
System.out.println("Thread " + row + " done working on C.");
|
2019-10-07 02:49:29 +00:00
|
|
|
workingOn.set(0, workingOn.get(0) - 1);
|
|
|
|
workingOn.set(1, workingOn.get(1) + 1);
|
|
|
|
}
|
2019-10-07 03:12:48 +00:00
|
|
|
try {
|
|
|
|
System.out.println("Thread " + row + " waiting on barrier.");
|
|
|
|
barrier.await();
|
|
|
|
System.out.println("Thread " + row + " done waiting on barrier.");
|
|
|
|
|
|
|
|
} catch (BrokenBarrierException e) {
|
|
|
|
System.out.println("Barrier broken!");
|
|
|
|
return;
|
|
|
|
} catch (InterruptedException e) {
|
|
|
|
System.out.println("Thread " + row + " interrupted!");
|
|
|
|
return;
|
|
|
|
}
|
2019-10-07 02:49:29 +00:00
|
|
|
for (int col = 0; col < SIZE; col++) {
|
|
|
|
d[row][col] = computeAtPosition(c, a, row, col);
|
|
|
|
}
|
|
|
|
synchronized (workingOn) {
|
2019-10-07 03:12:48 +00:00
|
|
|
System.out.println("Thread " + row + " done working on D.");
|
2019-10-07 02:49:29 +00:00
|
|
|
workingOn.set(1, workingOn.get(1) - 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2019-10-07 02:38:37 +00:00
|
|
|
}
|