Pthreads矩阵-向量程序

以下是一个使用Pthreads库编写的矩阵-向量程序：

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

#define MAX_THREADS 16

int threads_count;
int matrix_size;
double *matrix;
double *vector;
double *result;
pthread_barrier_t barrier;

void *Multiply_matrix(void* rank) {
    long my_rank = (long) rank;
    int rows_per_thread = matrix_size / threads_count;
    int my_first_row = my_rank * rows_per_thread;
    int my_last_row = (my_rank + 1) * rows_per_thread - 1;
    int i, j;

    for (i = my_first_row; i <= my_last_row; i++) {
        result[i] = 0.0;
        for (j = 0; j < matrix_size; j++) {
            result[i] += matrix[i * matrix_size + j] * vector[j];
        }
    }

    pthread_barrier_wait(&barrier);

    if (my_rank == 0) {
        double sum = 0.0;
        for (i = 0; i < matrix_size; i++) {
            sum += result[i];
        }
        printf("The result is %f\n", sum);
    }

    return NULL;
}

int main(int argc, char* argv[]) {
    long thread;
    pthread_t* thread_handles;

    printf("Enter the number of threads: ");
    scanf("%d", &threads_count);

    printf("Enter the matrix size: ");
    scanf("%d", &matrix_size);

    matrix = (double*) malloc(matrix_size * matrix_size * sizeof(double));
    vector = (double*) malloc(matrix_size * sizeof(double));
    result = (double*) malloc(matrix_size * sizeof(double));
    thread_handles = (pthread_t*) malloc(threads_count * sizeof(pthread_t));

    pthread_barrier_init(&barrier, NULL, threads_count);

    for (int i = 0; i < matrix_size; i++) {
        for (int j = 0; j < matrix_size; j++) {
            matrix[i * matrix_size + j] = rand() / (double) RAND_MAX;
        }
        vector[i] = rand() / (double) RAND_MAX;
    }

    for (thread = 0; thread < threads_count; thread++) {
        pthread_create(&thread_handles[thread], NULL, Multiply_matrix, (void*) thread);
    }

    for (thread = 0; thread < threads_count; thread++) {
        pthread_join(thread_handles[thread], NULL);
    }

    pthread_barrier_destroy(&barrier);
    free(matrix);
    free(vector);
    free(result);
    free(thread_handles);

    return 0;
}

该程序首先输入线程数和矩阵大小，然后动态分配内存以存储矩阵、向量和结果。接下来，使用随机数填充矩阵和向量。然后，创建线程并调用Multiply_matrix函数，该函数使用矩阵和向量乘法计算结果。线程在计算结果后通过屏障同步。最后，主线程输出结果并释放内存。

在Multiply_matrix函数中，每个线程计算自己的行范围。然后，它迭代矩阵的每一行，并计算结果向量的对应元素。在计算完所有结果后，线程通过屏障同步。如果线程是第一个到达屏障的线程（即my_rank == 0），它将计算结果向量的总和并输出结果。

注意，该程序使用了动态内存分配和随机数生成，因此可能需要更多时间来运行。在实际应用中，可能需要使用其他方法来生成矩阵和向量。