Параллельное умножение матриц в java

public class Main {
    public static int N = 200;
    public static int P = 10;
    public static void main(String[] args) {
        for (int i = 0; i < P; i++) {
            Thread Ti = new MyThread(i);
            Ti.start();
        }
    }
}

class MyThread extends Thread {
    int N = Main.N;
    int P = Main.P;
    int H = N/P;
    private long time;
    private int threadId;
    public MyThread(int id) {
       this.threadId = id;
    }
    int [][] MX = new int[N][N];
    int [][] MR = new int[N][N];
    int [][] MXMR = new int[N][N];

public void run() {
    for(int i = 0; i < N; i++){
        for(int j = 0; j < N; j++){
            MX[i][j] = 1;
            MR[i][j] = 1;
        }
    }
    if (threadId == 0){
        time = System.currentTimeMillis();
    }
    for (int i = H*threadId; i < H*(threadId + 1); i++) {
        for (int j = 0; j < N; j++) {
            MXMR[i][j] = 0;
            for (int k = 0; k < N; k++) {
                MXMR[i][j] += MX[i][k] * MR[k][j];
            }
        }
    }
    if(threadId == 0){
        System.out.println(System.currentTimeMillis() - time);
    }


}
}

У меня есть код, который должен параллельно умножать квадратные матрицы, при этом количество потоков P можно менять, но при одном и том же размере матрицы(N), при увеличении числа потоков время выполнения увеличивается! а не уменьшается. Например при P=1, N=200 время выполнения = 16мс, а при N=200 и P=10, время выполнения уже 52 мс! аналогично и для P =4,6,5 - время выполнения больше чем при меньшем числе потоков. При этом на моём компьютере 12 потоков и 6 ядер. Почему так происходит? ведь при увеличении числа потоков, каждый поток выполняет меньшее число операций(H) и время выполнения должно уменьшатся. При этом для больших значений N(> 1500), всё работает почти как надо, а именно с увеличением числа потоков, время выполнения уменьшается.