用两个线程完成 6x6 矩阵与 6x10 矩阵的相乘。提示：矩阵中元素值随机产生， 让线程1计算结果矩阵的前3行（行 0-2），让线程2计算后3行（行 3-5）。 这两个线程并行运行，分别计算它们负责的部用Java

在Java中，我们可以使用`java.util.concurrent`包下的`ExecutorService`和`Callable`接口来实现两个线程同时计算矩阵的相乘。这里是一个简单的示例：

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.*;

public class MatrixMultiplication {
    private static final int ROWS = 6;
    private static final int COLS = 6;

    // 定义矩阵的大小和元素生成器
    private static Random random = new Random();
    
    // 创建两个任务来处理矩阵的相应部分
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(2); // 创建一个固定大小的线程池

        // 创建两个Callable任务，每个任务负责矩阵的一部分相乘
        Callable<Integer[][]> task1 = () -> multiplyMatricesPartially(new int[ROWS, COLS], new int[ROWS, 10], 0, 2);
        Callable<Integer[][]> task2 = () -> multiplyMatricesPartially(new int[ROWS, COLS], new int[ROWS, 10], 3, 5);

        Future<Integer[][]> future1 = executor.submit(task1);
        Future<Integer[][]> future2 = executor.submit(task2);

        // 获取并打印结果
        Integer[][] result1 = future1.get();
        Integer[][] result2 = future2.get();

        // 合并结果矩阵
        List<Integer[]> mergedResult = new ArrayList<>();
        for (int i = 0; i < ROWS; i++) {
            if (i >= 3) {
                mergedResult.add(result2[i - 3]);
            } else {
                mergedResult.add(result1[i]);
            }
        }

        printMatrix(mergedResult);
        executor.shutdown(); // 关闭线程池
    }

    // 私有方法：计算矩阵的部分乘法
    private static Integer[][] multiplyMatricesPartially(Integer[][] matrixA, Integer[][] matrixB, int startRow, int endRow) {
        int[][] result = new int[ROWS][COLS];
        for (int i = startRow; i <= endRow; i++) {
            for (int j = 0; j < COLS; j++) {
                for (int k = 0; k < matrixB[0].length; k++) {
                    result[i][j] += matrixA[i][k] * matrixB[k][j]; // 这里只是一个示例，实际应使用矩阵乘法算法
                }
            }
        }
        return result;
    }

    // 打印矩阵
    private static void printMatrix(List<Integer[]> rows) {
        for (Integer[] row : rows) {
            for (int elem : row) {
                System.out.print(elem + " ");
            }
            System.out.println();
        }
    }
}

这个示例中，我们创建了两个`Callable`任务，每个任务各自处理一个矩阵的一部分，并返回其结果。主线程提交这两个任务到线程池，然后获取并合并最终的结果。

注意这只是一个基础示例，实际的矩阵乘法应该使用更高效的算法，比如Strassen算法或分块乘法，而不是直接嵌套循环。此外，为了简化演示，元素值在这里是直接相乘而不是计算的，但在实际应用中你需要对它们进行加法操作。