从一个空列表开始，我需要两个线程同时运行，在 C 的同一个列表中插入 100 万个随机整数

Question

Starting with an empty list, I need two threads running at the same time to insert 1 million random integers each on the same list in C. I am trying to pass the empty list to a thread being created. The function does not seem to recognize the previously created list. I believe it is because I am passing it wrong. The error is as follows:

error: 'my_list' undeclared (first use in this function); did you mean 'va_list'? List_Insert(&my_list, 32);

Any advice would be appreciated.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <errno.h> 
#include <unistd.h>
#include <pthread.h>

//basic node structure
typedef struct __node_t {
    int     key;
    struct __node_t     *next;
} node_t;

//basic list structure (one used per list)
typedef struct __list_t {
    node_t      *head;
    pthread_mutex_t lock;
} list_t;


void List_Init(list_t *L) {
    L->head = NULL;
    pthread_mutex_init(&L->lock, NULL);
}

int List_Insert(list_t *L, int key) {
    pthread_mutex_lock(&L->lock);
    node_t *new = malloc(sizeof(node_t));
    if (new == NULL) {
        perror("malloc");
        pthread_mutex_unlock(&L->lock);
        return -1; //fail
    }
    new->key = key;
    new->next = L->head;
    L->head = new;
    pthread_mutex_unlock(&L->lock);
    return 0;  //success
}

int List_Lookup(list_t *L, int key) {
    pthread_mutex_lock(&L->lock);
    node_t *curr = L->head;
    while (curr) {
        if (curr->key == key) {
            pthread_mutex_unlock(&L->lock);
            return 0; //success
        }
        curr = curr->next;
    }
    pthread_mutex_unlock(&L->lock);
    return -1; //failure
}

//Ensures function executes after main
void *myThread(void *vargp) __attribute__((destructor));

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

//Define an empty list
list_t my_list;

//Initialize the list
List_Init(&my_list);

//Create the threads
int i;
pthread_t tid;

for (i = 0; i < 2; i++)
    pthread_create(&tid, NULL, myThread, (void *)&my_list);

pthread_exit(NULL);
return 0;

}

//Function to be executed by both threads
void *myThread(void *vargp)
{
    ////FUNCTION NOT RECOGNIZING PREVIOUSLY CREATED LIST////
    printf("Inserting into list\n");
    List_Insert(&my_list, 32);

}

Answer 1

There's no my_list in the thread function. Once you passed my_list from main, you can access it through the local variable vargp (which is what "my_list" now)

So you might be interested in:

void *myThread(void *vargp)
{
    printf("Inserting into list\n");
    List_Insert(vargp, 32);
    return NULL; // see man pthread_create
}

But...this is wrong. Because my_list is a local variable (local to main ). So once you exit the main thread, you can no longer access "my_list". So either you'll have to wait for the threads to complete with pthread_join() calls for the two threads )For that, you'd need to save pthread_t ids of each thread - currently you're overwriting the thread ids).

Or you'd have to allocate it with:

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

    //Define an empty list
    list_t *my_list = malloc(sizeof *my_list);

    //Initialize the list
    List_Init(my_list);

    //Create the threads
    int i;
    pthread_t tid;

    for (i = 0; i < 2; i++)
        pthread_create(&tid, NULL, myThread, my_list);

    pthread_exit(NULL);
    return 0;

}

which you can free() later. Then you'd be able to use myThread as above.

You have other problems:

• The destructor attribute will make the myThread be called again at the end. This is almost certainly not what you want. You probably want the thread to carry on while the main thread exits. For that, calling pthread_exit() as currently do is sufficient. So simply remove this attribute __attribute__((destructor)) from the function prototype.

• You should avoid using identifier with __ as they're reserved names.

• Your thread function should return a pointer (as required by pthread_create API).

Answer 2

Well, my_list is a variable declared inside the main 's scope. So it is not visible inside myThread function. You can simply achieve this by using your vargp argument:

void *myThread(void *vargp)
{
    list_t *my_list = (list_t *)vargp;
    printf("Inserting into list\n");
    List_Insert(my_list, 32);
    // Notice the missing & in the call!
}

Another problem is that the list is allocated inside the main() function's stack frame. That means that after main returns, that stack frame is no longer accessible and you will have undefined behaviour. You have 2 options here:

1. Either allocate your list on heap using malloc

2. Wait for all the threads inside the main function, so the stack frame of main stays alive while your threads use that list.