Многопоточное перемножение матриц

import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import java.util.stream.Stream;
 
public class Main {
 
    public static void main(String[] args) throws InterruptedException {
        UsualMatrix a = new UsualMatrix(3, 4, 0);
        a.randNum();
        System.out.println(a.toString());
        UsualMatrix b = new UsualMatrix(4, 3, 0);
        b.randNum();
        System.out.println(b.toString());
        UsualMatrix res1;
        UsualMatrix res2;
 
 
        long startTime = System.currentTimeMillis();
        res1 = a.mult(b);
        System.out.println("__________________________________");
        System.out.println(res1.toString());
        long estimatedTime = System.currentTimeMillis() - startTime;
        //System.out.print(oneResult);
        System.out.println("Умножается за время: " + estimatedTime + "ms");
 
        ParallelMatrixProduct test = new ParallelMatrixProduct(a, b, Runtime.getRuntime().availableProcessors());
        long startTime1 = System.currentTimeMillis();
        res2 = test.parallelProduct();
        System.out.println(res2.toString());
        long estimatedTime1 = System.currentTimeMillis() - startTime1;
        System.out.println("(Умножается за время): " + estimatedTime1 + "ms");
    }
 
}

import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import java.util.stream.Stream;
 
public class ParallelMatrixProduct {
    private int threads;
    private UsualMatrix x;
    private UsualMatrix y;
    private UsualMatrix result;
    private int num;
 
    private class myThread implements Runnable {
        private int index1;
        private int index2;
 
        public myThread(int i, int j) {
            this.index1 = i;
            this.index2 = j;
        }
 
        @Override
        public void run() {
            if (x.col == y.row) {
                for (int k = 0; k < y.col; k++) {
                    result.setEl(this.index1, this.index2, result.getEl(this.index1, this.index2) + x.getEl(this.index1, this.index2) * y.getEl(k, this.index2));
                }
            }
            else {
                System.out.println("-1000");
            }
        }
    }
 
    ParallelMatrixProduct(UsualMatrix x, UsualMatrix y, int threads) {
        this.x = x;
        this.y = y;
        this.threads = threads;
        this.result = new UsualMatrix(x.col, y.row, 0);
    }
 
    public UsualMatrix parallelProduct() throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(this.threads);
        for (int i = 0; i < x.row; i++) {
            for (int j = 0; j < y.col; j++) {
                executorService.execute(new myThread(i, j));
            }
        }
        executorService.shutdown();
        executorService.awaitTermination(1, TimeUnit.MILLISECONDS);
        return this.result;
    }
}

import java.util.Random;
 
public class UsualMatrix {
    protected int[][] matrix;
    protected int col;
    protected int row;
 
 
    public UsualMatrix(int data) {
        this.row = data;
        this.col = data;
        this.matrix = new int[data][data];
    }
 
    public UsualMatrix(int size, int val) {
        this.row = size;
        this.col = size;
        this.matrix = new int[size][size];
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                matrix[i][j] = val;
            }
        }
    }
 
    public UsualMatrix(int r, int c, int value) {
        this.row = r;
        this.col = c;
        this.matrix = new int[r][c];
        for (int i = 0; i < r; i++) {
            for (int j = 0; j < c; j++) {
                matrix[i][j] = value;
            }
        }
    }
    public void setEl(int row, int col, int value) {
        this.matrix[row][col] = value;
    }
 
    public int getEl(int row, int col) {
        return this.matrix[row][col];
    }
 
    public void randNum() {
        Random r = new Random();
        this.matrix = new int[this.row][this.col];
        for(int i = 0; i != this.row; i++) {
            for(int j = 0; j != this.col; j++) {
                this.matrix[i][j] = r.nextInt(9) + 1;
            }
        }
    }
 
    public UsualMatrix mult(UsualMatrix mtx) {
        if (this.col == mtx.row) {
            UsualMatrix result = new UsualMatrix(this.row, mtx.col, 0);
            for (int i = 0; i < this.row; i++) {
                for (int j = 0; j < mtx.col; j++) {
                    for (int k = 0; k < this.col; k++) {
                        result.setEl(i, j, result.getEl(i, j) + this.getEl(i, j) * mtx.getEl(k, j));
                    }
                }
            }
            return result;
        } else {
            System.out.println("-1000");
            return this;
        }
    }
 
    public String toString() {
        StringBuilder result = new StringBuilder();
        for (int i = 0; i != this.row; i++) {
            for (int j = 0; j != this.col; j++) {
                result.append("|").append(this.getEl(i, j)).append("|");
            }
            result.append("\n");
        }
        return result.toString();
    }
 
}