为什么我不能将 void* 转换回 int* 并取消引用它？

Question

Im trying to understand threading in C from a lab from my teacher and this is the way he had us do it in class.

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

#define numberlen 1000000
int sum = 0;
int arr[numberlen];


void* Summing(void* param)
{
    int n = *((int*)param); //I'm guessing this is where my issue is but I'm still a first year so i'm not sure.
    int base = 500000 * n;
    for(int i =0; i<500000;i++)
    {
        sum += arr[i+base];
    }
}




int main()
{
    int nonthreadsum = 0;
    pthread_t thread_id_first;
    pthread_t thread_id_second;
    


    srand(time(NULL)); 
    
    for(int i = 0; i<numberlen;i++)
    {
        int r = (rand() % 10);
        arr[i] = r;
        nonthreadsum += r;
    }
    printf("%d\n",nonthreadsum);

    pthread_create(&thread_id_first, NULL, Summing, (void*)0);
    pthread_create(&thread_id_second, NULL, Summing, (void*)1);

    
    printf("%d\n", sum);


    return 1;
}

The issue I keep running into is that pthread functions only allow void*'s as arguments to pass to the actual function to be run. Otherwise I'd just put 0 or 1 in as the argument. If anyone knows a way around this i'd appreciate it.

Answer 1

It's allowed (in some cases) to cast from an integer to a pointer and from a pointer to an integer. The problem is that's not what you're attempting to do.

When you call pthread_create , you're casting the integer values 1 and 0 to type void * . This is fine. But then in the thread function you do this:

int n = *((int*)param); 

You cast the void * argument to int * and then attempt to dereference that pointer. But you didn't pass in an int * . You passed an int . So your program is treating the values 1 and 0 as pointers (the latter of which is actually a NULL pointer).

Since you converted from int to void * when you passed the values to the function, you want to cast back to int inside of the function.

int n = (int)param; 

That being said, the best way to handle this would be to pass an actual int * to the function and convert it back in the function. Converting from an int * to a void * and back is well defined in all cases.

You can do this by defining variables in the main function to dynamically create memory to hold these values:

int *t1_val = malloc(sizeof(*t1_val));
int *t2_val = malloc(sizeof(*t2_val));
*t1_val = 0;
*t2_val = 1;
pthread_create(&thread_id_first, NULL, Summing, t1_val);
pthread_create(&thread_id_second, NULL, Summing, t2_val);

Then using them in the thread as you were, adding a call to free :

int n = *((int*)param);
free(param);

You could also do this without dynamic allocation by using variables of type int and passing their address, but you would need to make sure those variables don't go out of scope by the time the thread attempts to dereference the pointer.

Answer 2

Pass the Address of Your Data to Your Thread

Pass the address of your data to a thread. Do not pass your data inside a pointer.

The intended way to pass data to a thread is to pass a pointer to it. For example, to pass data whose type is Type , you can use:

Type x;
// … Set desired value(s) in x.
pthread_create(&thread_id_first, NULL, Summing, &x);

You can pass (void *) &x but do not need to. The conversion to void * will be automatic in C, for a parameter declared as type void * .

Then, in the thread, you should restore the pointer type:

void *Summing(void *param)
{
    Type *p = param;
    Type x = *p;
    // … Use x.
}

The conversion of the pointer from void * ( Type *p = param; ) and the use of the pointer ( Type x = *p; ) are shown in two lines above for illustration. However, you can combine them into one line: Type x = * (Type *) param; .

Why void * Is Used

Any kind of data can be passed to a thread, via an address. However, C does not have good provisions for passing any kind of pointer to a routine. pthread_create must be declared with a specific pointer type. void * is used to serve as a generic type of pointer. So pthread_create has a void * parameter, but you can pass it any type of pointer to an object.

In your case, the type can be an int , replacing Type in the sample code above. Given int x; , &x will be a pointer to an int , int * . When you pass it to pthread_create , it will be automatically converted to void * .

Then, in the thread, you need to convert it back to an int * . After you do that, you can access the int that it points to.

Passing Lots of Data

Threads are often passed more data than just a simple int . The Type can be an object type. Often, a structure is used. A program will define a structure, such as:

struct foo
{
    int start;
    int end;
    double coefficient;
    double ReferenceData[30];
}

As with the Type example, one would create an object of the desired type, struct foo x; , fill it with data, and pass &x to pthread_create . Then the thread will convert the void * it receives to struct foo * and use it to access the data.

In this case, because there is so much data, the thread might not want to copy it, which is what struct foo x = * (struct foo *) param; does. Instead, the thread might just make a pointer of the right type, struct foo *p = param; . Then the thread can use the data through the -> operator: p->start , p->ReferenceData[i] , and so on.

Threads can also pass results back to their creators this way, by putting results in the pointed-to-data.

Passing Just a Little Data

To pass a small amount of data, there is a shortcut: You can create an object and pass its address using a compound literal:

pthread_create(&thread_id_first, NULL, Summing, & (int) {1});`.

This creates an int object with the value 1 and passes its address to pthread_create . Then the thread would get the int with int x = * (int *) param; .

Generally, the code construction ( type ) { initial values } is called a compound literal. It creates an object with type type and the given initial values. The & takes its address.

Compound literals have automatic storage duration, so the & (int) {1} will exist (have memory reserved for it) only until the end of the execution of the routine that creates it. You should not let that routine end until the thread is done using the compound literal.

If you need an object to persist longer than execution of the routine that will create the thread, you can use malloc to reserve memory for the data.