How to use thread pool and message queues in Multithreaded Matrix Multiplication?

help you fix your problem It is not okay to block TP threads on dbase queries. The quoted phrase stipulates that it is only okay if all of the TP threads are blocking on such queries. Can't argue with that but it seems rather artificial.
The threadpool manager's primary job is to ensure that it never runs more threads than there are available cores in the machine. Because that makes threading inefficient, context switching between threads is pretty expensive. That however won't work very well if an executing TP thread is blocking and not doing any real work. The TP manager isn't smart enough to know that a TP thread is blocking and cannot predict for how long it is going to block. Only the dbase engine would have a guess at it and it doesn't tell.

may help you . Big Boss is right in the sense that he has identified the problem, but to add to/augment the reply he made.
Option 1: Just create an arg_struct in the loop and set the members, then pass it through:

for(...)
{
    struct arg_struct *args = (arg_struct*)malloc(sizeof(struct arg_struct)); 
    args->arg1 = A;
    args->arg2 = B;    //set up args as now...
    ...
    x = pthread_create(&allthreads[i], NULL, &matrixMultiplication, (void*)args);
    ....
}

arg_struct args;
//set up args as now...
for(...)
{
   ...
   x = pthread_create(&allthreads[i], NULL, &matrixMultiplication, (void*)&args);
}

To fix the issue you can do Set the flag parameter on msgrcv (the 5th parm) to IPC_NOWAIT. This makes the queue receive non-blocking.

it helps some times The answer to the big mystery this this: The time required to do the matrix multiplication is dominated by the time spent moving data from RAM to the CPU cache. You may have 4 cores, but you only have 1 RAM bus, so you won't get any benefit by using more cores (multithreading) if they all block each other waiting for memory access.
The first experiment you should try is this: Write the single-threaded version using the matrix transpose and vector multiplication. You will find that it is MUCH faster -- probably about as fast as the multithreaded version with the transpose.

for(int i=0; i<n; i++)
{
    for(int j=0; j<n; j++)
    {
        final double[] v1 = matrix1[i];
        final double[] v2 = matrix2[j];
        result[i][j] = exe.submit(() -> vecdot(v1,v2));
    }
}

With these it helps By calling future.get() right after executor.submit(...), you are preventing any actual multithreading. Your program waits for the first computation to complete before it submits the second one.
To illustrate this, try replacing your loop with the following:

Future<Integer> futures[][] = new Future[n][n];

for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
        future = executor.submit(new NaiveMatMul(n, a, b, i, j));
        futures[i][j] = future;
    }
}

for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
        c[i][j] = futures[i][j].get();
    }
}