Умножение матриц: многопоточность

public class MultiplierMT extends Thread {
    private final int[][] firstMatrix;
    private final int[][] secondMatrix;
    private final int[][] resultMatrix;
    private final int firstIndex;
    private final int lastIndex;
    private final int sumLength;
 
    public MultiplierMT(final int[][] firstMatrix, final int[][] secondMatrix, final int[][] resultMatrix, final int firstIndex, final int lastIndex)
    {
        this.firstMatrix  = firstMatrix;
        this.secondMatrix = secondMatrix;
        this.resultMatrix = resultMatrix;
        this.firstIndex   = firstIndex;
        this.lastIndex    = lastIndex;
        sumLength = secondMatrix.length;
    }
 
    private void calcValue(final int row, final int col)
    {
        int sum = 0;
        for (int i = 0; i < sumLength; ++i)
            sum += firstMatrix[row][i] * secondMatrix[i][col];
        resultMatrix[row][col] = sum;
    }
 
    @Override
    public void run()
    {
        System.out.println("Thread " + getName() + " started. Calculating cells from " + firstIndex + " to " + lastIndex + "...");
 
        final int colCount = secondMatrix[0].length;  // Число столбцов результирующей матрицы.
        for (int index = firstIndex; index < lastIndex; ++index)
            calcValue(index / colCount, index % colCount);
 
        System.out.println("Thread " + getName() + " finished.");
    }
}
 
public class Main {
    private static int[][] multiplyMatrix(final int[][] firstMatrix, final int[][] secondMatrix)
    {
        final int rowCount = firstMatrix.length;
        final int colCount = secondMatrix[0].length;
        final int sumLength = secondMatrix.length;
        final int[][] result = new int[rowCount][colCount];
 
        for (int row = 0; row < rowCount; ++row) {
            for (int col = 0; col < colCount; ++col) {
                int sum = 0;
                for (int i = 0; i < sumLength; ++i)
                    sum += firstMatrix[row][i] * secondMatrix[i][col];
                result[row][col] = sum;
            }
        }
        return result;
    }
 
    private static void printMatrix(final int[][] matrix)
    {
        for (int row = 0; row < matrix.length; ++row) {
            for (int col = 0; col < matrix[0].length; ++col) {
                System.out.printf("%8d", matrix[row][col]);
            }
            System.out.println();
        }
    }
 
 
    private static void fillMatrix(final int[][] matrix)
    {
        final Random random = new Random();
 
        for (int row = 0; row < matrix.length; ++row)
            for (int col = 0; col < matrix[row].length; ++col)
                matrix[row][col] = random.nextInt(100);
    }
 
 
 
    // --------------------------------------------------------
    private static int[][] multiplyMatrixMT(final int[][] firstMatrix, final int[][] secondMatrix, int threadCount)
    {
        assert threadCount > 0;
 
        final int rowCount = firstMatrix.length;
        final int colCount = secondMatrix[0].length;
        final int[][] result = new int[rowCount][colCount];
 
        final int cellsForThread = (rowCount * colCount) / threadCount;
        int firstIndex = 0;
        final MultiplierMT[] multiplierMt = new MultiplierMT[threadCount];
 
 
        for (int threadIndex = threadCount - 1; threadIndex >= 0; --threadIndex) {
            int lastIndex = firstIndex + cellsForThread;
            if (threadIndex == 0) {
                lastIndex = rowCount * colCount;
            }
            multiplierMt[threadIndex] = new MultiplierMT(firstMatrix, secondMatrix, result, firstIndex, lastIndex);
            multiplierMt[threadIndex].start();
            firstIndex = lastIndex;
        }
 
        try {
            for (final MultiplierMT multiplierThread : multiplierMt)
                multiplierThread.join();
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
 
        return result;
    }
 
 
    //----------------------------------------------------------
 
    public static void main(String[] args) {
        final int FMROWS = 20;
        final int FMCOLS = 20;
        final int SECMROWS = FMCOLS;
        final int SECMCOLS = 20;
        final int THREAD_QTY = 4;
        final int[][] firstMatrix  = new int[FMROWS][FMCOLS];    // Первая (левая) матрица.
        final int[][] secondMatrix = new int[SECMROWS][SECMCOLS];
 
        fillMatrix(firstMatrix);
        fillMatrix(secondMatrix);
 
        System.out.println("First matrix:");
        printMatrix(firstMatrix);
        System.out.println();
        System.out.println("Second matrix:");
        printMatrix(secondMatrix);
        System.out.println();
        System.out.println("Single thread multiplying...");
        long startTime = System.nanoTime();
        int[][] resultMatrix = multiplyMatrix(firstMatrix, secondMatrix);
        long totalTime = System.nanoTime() - startTime;
        System.out.println("Single thread multiplying has finished, it took " + totalTime + " ns");
        System.out.println("Result matrix:");
        printMatrix(resultMatrix);
 
        System.out.println("--------------------------------------");
 
        System.out.println("Multi thread multiplying...");
        startTime = System.nanoTime();
        resultMatrix = multiplyMatrixMT(firstMatrix, secondMatrix, THREAD_QTY);
        totalTime = System.nanoTime() - startTime;
        System.out.println("Multi thread multiplying has finished, it took " + totalTime + " ns");
        System.out.println("Result matrix:");
        printMatrix(resultMatrix);
    }
}