在C中使用pthreads的数组的最小值和最大值

Question

我的代码有问题。 免责声明，我是C的新手。尝试自己学习它。 无论如何，我正在尝试获取数组的最小值和最大值。 我将数组分为4个部分，制作了4个单独的数组，然后使用这4个数组传入每个线程的参数之一。 话虽这么说，我只能获得数组每个部分的最大值，而不能获得最小值，我也不知道为什么。

Answer 1

我认为我们可以简化您的代码，避免所有这些不必要的malloc调用，并简化在数组中查找最小/最大对的算法。

首先具有一个线程函数，该函数将以下各项作为输入：数组（由指针表示），从中开始搜索的数组索引和从中停止的数组索引。 此外，此函数将需要两个输出参数-在找到的数组子集中找到的最小和最大整数。

从参数声明开始。 与您的MaxMin相似，但具有输入和输出参数：

struct ThreadParameters
{
    // input
    int* array;
    int start;
    int end;

    // output
    int smallest;
    int largest;
};

然后是一个线程函数，它从array[start]一直扫描到（但不包括） array[end] 。 并将其扫描结果放入上述结构的smallest和largest成员中：

void* find_min_max(void* args)
{
    struct ThreadParameters* params = (struct ThreadParameters*)args;
    int *array = params->array;
    int start = params->start;
    int end = params->end;
    int smallest = array[start];
    int largest = array[start];


    for (int i = start; i < end; i++)
    {
        if (array[i] < smallest)
        {
            smallest = array[i];
        }

        if (array[i] > largest)
        {
            largest = array[i];
        }
    }

    // write the result back to the parameter structure

    params->smallest = smallest;
    params->largest = largest;

    return NULL;
}

当我们使用它时，请使用大写字母作为宏：

#define THREAD_COUNT 4

现在，您可以继续使用“ 4个单独的阵列”设计。 但是，由于线程函数可以扫描任何数组的任何范围，因此没有理由。 因此，让我们声明一个全局数组，如下所示：

#define ARRAY_SIZE 400
int arr[ARRAY_SIZE];

大写字母首选使用大写字母语法。

fillArray变得更简单：

void fillArray()
{
    for (int i = 0; i < ARRAY_SIZE; i++)
    {
        arr[i] = rand() % 1000 + 1;
    }
}

现在，通过执行以下技术，变得非常简单：

• 我们将利用堆栈来分配线程参数结构（无malloc和free）

• 我们将简单地启动4个线程-向每个线程传递一个指向 ThreadParameter结构的指针 。 由于线程不会超过main ，因此很安全。

• 启动每个线程后，我们只需等待每个线程完成）

• 然后，我们扫描线程参数列表以获取最终的最小和最大。

main变得更容易管理：

int main()
{
    int smallest;
    int largest;

    // declare an array of threads and associated parameter instances
    pthread_t threads[THREAD_COUNT] = {0};
    struct ThreadParameters thread_parameters[THREAD_COUNT]  = {0};

    // intialize the array    
    fillArray();

    // smallest and largest needs to be set to something
    smallest = arr[0];
    largest = arr[0];

    // start all the threads
    for (int i = 0; i < THREAD_COUNT; i++)
    {
        thread_parameters[i].array = arr;
        thread_parameters[i].start = i * (ARRAY_SIZE / THREAD_COUNT);
        thread_parameters[i].end = (i+1) * (ARRAY_SIZE / THREAD_COUNT);
        thread_parameters[i].largest = 0;
        pthread_create(&threads[i], NULL, find_min_max, &thread_parameters[i]);
    }

    // wait for all the threads to complete
    for (int i = 0; i < THREAD_COUNT; i++)
    {
        pthread_join(threads[i], NULL);
    }

    // Now aggregate the "smallest" and "largest" results from all thread runs    
    for (int i = 0; i < THREAD_COUNT; i++)
    {
        if (thread_parameters[i].smallest < smallest)
        {
            smallest = thread_parameters[i].smallest;
        }

        if (thread_parameters[i].largest > largest)
        {
            largest = thread_parameters[i].largest;
        }
    }

    printf("Smallest is %d\n", smallest);
    printf("Largest is %d\n", largest);

}