CODEWITHSUNDEEP
cmultithreading
Neil
Neil

Reputation: 13

weird thread return value in C

I think the print result should be 500, but the result was weird - it said 32728, which is meaningless.

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

void* testFunction(void*);

int main(void)
{
  void* result;
  pthread_t tid;

  pthread_create(&tid, NULL, testFunction, NULL);
  pthread_join(tid, &result);

  printf("%d\n", *((int*)result));
}

void* testFunction(void* args)
{
  int time;
  time = 500;
  pthread_exit((void*)&time);
}

In this code, this is the flow of what I thought

  1. (void*)result has time's address.

  2. (int*)result has time's address. Because of (int*), the program should know result variable is referring to int-type variable.

  3. *((int*)result) means the value of what result variable refers to, so it would be time's value, which is 500.

Can you let me know what I thought wrong?

Upvotes: 0

Views: 77

Answers (3)

alk
alk

Reputation: 70893

As others already pointed out, the problem is that the pointer received by pthread_join() points nowhere the moment the function returned. As the memory allocate for int time has already been deallocated, as the function has already ended.

There are two possibilities to have pthread_join() return a pointer to valid memory:

  • Have the thread function allocate it dynamically.

    #include <stdlib.h> /* For malloc() and free(). */
#include <stdio.h>
#include <pthread.h>

void* testFunction(void* pv_unused)
{
  int * ptime = malloc(sizeof *ptime);
  /* Add error checking/handling here! */

  *ptime = 500;

  pthread_exit(ptime);
}

int main(void)
{
  ...

  pthread_join(tid, &result);

  printf("%d\n", *((int*)result));

  free(result); /* Free the memory that has been allocated by the thread-function. */
}

  • Pass a pointer to valid memory to the thread-function.

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

void* testFunction(void* pv_time)
{
  int * ptime = pv_time;

  *ptime = 500;

  pthread_exit(ptime);
}

int main(void)
{
  pthread_t tid;
  int time;

  pthread_create(&tid, NULL, testFunction, &time);

  {
    void * pv;
    pthread_join(tid, &pv);
    if (pv != &time)
    {
      /* Something went wrong! */
    }
  }

  printf("%d\n", time);
}

Upvotes: 1

cup
cup

Reputation: 8237

The problem is that time no longer exists by the time you come to check it. One way around that is to play with the casting. Instead of

pthread_exit((void*)&time);

use

pthread_exit((void*)time);

Then, when you are extracting the result, use

*((int) result)

Another minimal fix is to make time a static. That way, it is not stored in the stack and always exists.

Upvotes: 1

paxdiablo
paxdiablo

Reputation: 881153

What's wrong is that time is going out of scope when the thread function exits, meaning that dereferencing its address is undefined behaviour. And you are dereferencing after that, since it happens after the pthread_join() call.

There's a chance that something else will be using that memory (probably on the stack but no mandated, since a stack isn't itself mandated), which would explain the strange value.

But, regardless of what's actually happening, it's not something you're allowed to do in C. Or, more correctly, you can do it, just don't expect sane results.

Upvotes: 1

Related Questions