0

我正在使用 POSIX 线程编写程序以在整数数组中找到 minimax。我的问题是如何确定我需要多少线程以及在线程函数内输出最小值和最大值是否正确?为什么我需要动态线程?

这是我的代码:

#include<pthread.h>
#include<stdlib.h>
#include<stdio.h>
#include<unistd.h>
#include<sys/wait.h>

#define num_of_threads 1
#define size 10

int array[size];

typedef struct st_minimax {
    int min;
    int max;
} minimax;

void *thread_minimax(void* ptr) { //thread is searching
    int i;
    minimax *data;
//    data = (minimax*) malloc(minimax);

    data = (minimax*) ptr;

    data->max = array[0];
    data->min = array[0];

    for (i = 0; i < size; i++) {
        if (array[i] > data->max)
            data->max = array[i];
        else if (array[i] < data->min)
            data->min = array[i];
    }

    printf("Thread is calculating...\n");
    printf("Min: %d", data->min);
    printf("Max: %d", data->max);

    pthread_exit(NULL); //exit thread
}

int main(int argc, char *argv[]) {

    pthread_t worker[num_of_threads];
    minimax data;
    int t;
    int i;
    int ret;

    for (i = 0; i < size; i++) { //initialize the array
        printf("enter value for %d: ", i);
        scanf("%d", &array[i]);
    }

    for(t=0;t<num_of_threads;t++)
{
    printf("creating threads...%d\n",t);
    ret = pthread_create(&worker[t], 0, thread_minimax, (void*) &data); //creating thread
    sleep(1);
    if (ret) {
        fprintf(stderr, "thread err %d", ret);
        exit(-1);
    }

}
    pthread_exit(NULL); //exit thread
return 0;
}
4

3 回答 3

1
  1. 您需要指定您的标准以确定您“需要”多少线程。如当前所写,您只需要 1,因为线程扫描整个数组。

  2. 线程从线程打印是可以的;但是,如果您试图找到单个数组的最小值和最大值,并在多个线程之间分解工作,那么您可能不想(相反,让主进程从每个线程的结果中获取整体答案)。

  3. 不知道关于动态数组和动态线程的问题是什么;main 可以为每个数组动态分配空间(类似于您在线程中注释掉的代码中所做的);您的线程中需要更加动态的内容是什么?

于 2012-01-04T15:18:41.470 回答
1

如何确定我需要多少线程

这个问题的本质不需要任何多线程编程。

在线程函数内输出最小值和最大值是否正确?

这并没有错。它完全基于您的需要(在这种情况下homework,这完全取决于您的教授想要什么!)。

以及如何修改程序以分配动态数组和动态线程

要动态分配数组,可以使用malloc()和释放它们,使用free()如下

int *ptr = NULL;
if ((ptr = (int *) malloc(sizeof(int) * len)) == NULL) {
    printf("unable to allocate memory \n");
    return -1;
}

/* you can use the ptr to read-from/write-to the allocated memory */

free(ptr);

而且,你是什么意思dynamic threads

OTOH,当我执行您的代码片段时,我没有发现任何问题。它工作得很好!

于 2012-01-04T15:18:55.000 回答
1

根据与 OP 作者的对话,应使用元素(即行和列)N创建(1d)数组,如果有数组,则应创建线程(对于数组 [0],线程 0)。线程应该在相应的数组上工作并获取该数组的和值。MNMNNminmax

这是执行此操作的代码!

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

/* N is the number of threads */
/* also N is the number of arrays */
/* row */
#define N 10 

/* M is the length of each array */
/* column */
#define M 10

/* the 2d array which contains N rows and M columns */
int **matrix;

void display(void)
{
    int i, j;
    for (i=0 ; i<N ; i++) {
        for (j=0 ; j<M ; j++) {
            printf("%3d  ", matrix[i][j]);
        }
        printf("\n");
    }
    return;
}

void * thread_handler(void *thread_id)
{
    int *id = (int *) thread_id;
    int i = *id, j; 
    int min = matrix[i][0];
    int max = matrix[i][0];

    for (j=1 ; j<M ; j++) {
        if (matrix[i][j] > max)
            max = matrix[i][j];
        if (matrix[i][j] < min)
            min = matrix[i][j];
    }

    printf("array[%d] min[%d] max[%d]\n", i, min, max);
    pthread_exit(NULL);
}

int main(void)
{
    int i, j, ret;
    pthread_t tids[N];
    int ids[N] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    srand(time(NULL));

    matrix = (int **) malloc (sizeof(int *) * N);
    for (i=0 ; i<N ; i++) 
        matrix[i] = (int *) malloc (sizeof(int) * M);

    for (i=0 ; i<N ; i++) {
        for (j=0 ; j<M ; j++) {
            matrix[i][j] = rand() % 500;
        }
    }

    display();

    for (i=0 ; i<N ; i++) {
        printf("Creating thread #%d \n", ids[i]);
        ret = pthread_create(&tids[i], NULL, thread_handler, &ids[i]);
        if (ret) {
            printf("unable to create thread! \n");
            exit(-1);
        } 
    }

    for (i=0 ; i<N ; i++) {
        pthread_join(tids[i], NULL);
    }

    pthread_exit(NULL);     

    for (i=0 ; i<N ; i++) 
        free(matrix[i]);
    free(matrix);

    return 0;
}

以下是输出:

$ gcc dynamic_array_threads.c -lpthread -o dat
$ ./dat 
441  252  474  311  468  435  376  361  273  183  
482   30   99   47   23  361  118  455  233  178  
457  492  346  449   27  344  201  376  153  230  
375   94  482  349  257  451  136  133  164  409  
317  147  291  416   46  167  129   17  474  214  
 47  283  206  393  232   85   90  285  461  243  
 16  188  189  350  389  299  153   25  432  170  
286  101  169  430  369  215  449  350   84  423  
417  131   59  123   25  143   61  467  429  374  
210  297   63  251  499  304   50    5  330  335  
Creating thread #0 
Creating thread #1 
array[0] min[183] max[474]
Creating thread #2 
Creating thread #3 
array[2] min[27] max[492]
Creating thread #4 
array[1] min[23] max[482]
Creating thread #5 
array[4] min[17] max[474]
Creating thread #6 
array[3] min[94] max[482]
array[5] min[47] max[461]
Creating thread #7 
array[6] min[16] max[432]
Creating thread #8 
Creating thread #9 
array[8] min[25] max[467]
array[9] min[5] max[499]
array[7] min[84] max[449]
$  

希望这可以帮助!

于 2012-01-04T16:13:08.560 回答