如何在pthread线程中创建memcpy？

Question

我正在尝试使用c ++中的pthreads做2个矩阵的总和。 我一直试图将线程内部计算的总和的结果传递给我的主函数。

要添加的2个值在结构内部：

struct sum{
    int value1;
    int value2;
    int result;
}typedef struct_sum;

并将包含值的结构作为参数传递给pthread_create()以便在线程内部执行操作。

这是我的例程：

void * routine(void * sum) {
    std::cout<<((struct_sum *)sum)->value1 + ((struct_sum *)sum)->value2<<std::endl;
    std::cout<<((struct_sum *)sum)->value1<<std::endl;
    std::cout<<((struct_sum *)sum)->value2<<std::endl;
    int i = (((struct_sum *) sum)->value1 + ((struct_sum *) sum)->value2);
//    memcpy(&(((struct_sum *)sum)->result), reinterpret_cast<const void *>(i), sizeof(i));
    ((struct_sum *)sum)->result = i;
    std::cout<<&(((struct_sum *)sum)->result)<<std::endl;
    pthread_exit(nullptr);
}

在前3个cout我检查我的值是否正确到达线程。 在最后一个cout （退出线程之前），我检查了结构的result元素的内存地址（因此，我可以看到它在main函数中具有相同的地址）。

主要功能如下：

int main(int argc, char * argv[]) {
    int mat_1[ROW_SIZE][COLUMN_SIZE] = {{1, 2},
                                        {6, 7}};
    int mat_2[ROW_SIZE][COLUMN_SIZE] = {{3, 15},
                                        {9, 14}};
    int mat_result[ROW_SIZE][COLUMN_SIZE];
    int mat_size = sizeof(mat_1) / sizeof(int);
    int row_size = sizeof(mat_1) / sizeof(mat_1[0]);
    int column_size = sizeof(mat_1[0]) / sizeof(int);
    pthread_t threads[mat_size];
    int thread_number = 0;
    int thread_handler;
    for (int row = 0; row < row_size; row++) {
        for (int column = 0; column < column_size; column++) {
            struct_sum *result;
            result = static_cast<struct_sum *>(malloc(sizeof(struct_sum)));
            result->value1 = mat_1[row][column];
            result->value2 = mat_2[row][column];
            result->result = 0;
            thread_handler = pthread_create(&threads[thread_number], nullptr, routine, result);
            if(thread_handler) return(-1);
            std::cout << &(result->result)<<std::endl;
            thread_number++;
            mat_result[row][column] = result->result;
//            free(result);
        }
    }
    pthread_exit(nullptr);
}

我有两个问题：

1. 即使结果在主线程和线程中具有相同的地址，当我将i的值复制到main函数中的((struct_sum *)sum)->result ， ((struct_sum *)sum)->result result->result仍为0。

2. 当我取消对memcpy()行的注释时，线程根本不会运行，所以我不知道我做错了什么。

我期望在我的main功能中，语句std::cout << (result->result) <<std::endl将返回操作结果，但当前值为0。

那么，如何在线程中正确执行memcpy() ？

Answer 1

您必须加入线程。 这意味着，等待他们完成。 您的工作方式基本上是启动线程，而不给它保证的时间做任何事情。 除此之外，对API进行了一些重要更改，请检查以下注释：

void * routine(void * sum) {
    int i = (((struct_sum *) sum)->value1 + ((struct_sum *) sum)->value2);
    ((struct_sum *)sum)->result = i;

    // notice you don't need memcpy(), in fact...
    // but you could use it here if you want... it won't fail.

    // you have to use this function so it return your result to the main thread.
    pthread_exit(sum);
}

int main(int argc, char * argv[]) {
    int mat_1[ROW_SIZE][COLUMN_SIZE] = {{1, 2},
                                        {6, 7}};
    int mat_2[ROW_SIZE][COLUMN_SIZE] = {{3, 15},
                                        {9, 14}};
    int mat_result[ROW_SIZE][COLUMN_SIZE];
    int mat_size = sizeof(mat_1) / sizeof(int);
    int row_size = sizeof(mat_1) / sizeof(mat_1[0]);
    int column_size = sizeof(mat_1[0]) / sizeof(int);
    pthread_t threads[mat_size];
    int thread_number = 0;
    int thread_handler;
    for (int row = 0; row < row_size; row++) {
        for (int column = 0; column < column_size; column++) {
            struct_sum *result;
            result = static_cast<struct_sum *>(malloc(sizeof(struct_sum)));
            result->value1 = mat_1[row][column];
            result->value2 = mat_2[row][column];
            result->result = 0;
            thread_handler = pthread_create(&threads[thread_number], nullptr, routine, result);
            if(thread_handler) return(-1);
            // std::cout << &(result->result)<<std::endl;
            thread_number++;
            // forget this line below
            // mat_result[row][column] = result->result;
        }
    }

    // here you wait for the threads to JOIN
    // here it means they actually "finished" their job
    for (int i = 0; i < mat_size; i++)
    {
        struct_sum *result;

        // here you wait for the threads to finish their job
        // add something to your struct to "identify" the thread, so
        // you can figure out where in the final matrix you put the result
        pthread_join(threads[i], (void**)&result);
        std::cout << result->result << "\n";

        // this will print the correct sums: 4, 17, 15 and 21
        // notice: it will be printed in ANY order, once you
        // don't know which thread will finish first
        // but result->result has the... result you need!
        // you have to figure out how to fit this result in your matrix.
        // but this is out of scope of the question
        // and you can do yourself. have fun! :-)

        // here you can free the result, you already got the value!
        free(result);
    }

    // you don't need this line below... this goes to routine()
    // pthread_exit(nullptr);
    return 0;
}