Returning single integer value from thread

Question

I need help returning integer value from thread. I have tried several things and can't get it to work. I am new to C and yes this is homework, but I am stuck and need some help on this. I have created the pointer in the thread but when I pass it back to main, it does not show the right value. I have tried malloc and that does not work either. Any tips would be appreciated.

Here is the Code:

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<pthread.h>
#include "FindNextHigher.h"
#include "SortNumber.h"

void *thread_next(void *arg)
{
   /* Call FindNextHigher */
   int *num =(int *)arg;
   int next = FindNextHigher(*num);
   printf("next= %d\n", next);
   /* Convert int to pointer to pass and print to check*/
   int *next_ptr=&next;
   printf("nextptr= %d\n", *next_ptr);
   return (void *)next_ptr;
}

int main(int argc, char *argv[])
{
   FILE* f = fopen(argv[1], "r");
   int i, num, *next_ptr;
   printf("next_ptr = %d\n", *next_ptr);
   pthread_t thread1, thread2, thread3, thread4;
   void *exit_status;

   for(i=1; i<=20; i++)
   {
   fscanf(f, "%d", &num);
   if (i==1 || i<=60){
     pthread_create(&thread1, NULL, thread_next, &num);
     pthread_join(thread1, &exit_status);
     printf("Threadid 1 processes number %d which is %d and the next higher number is %d\n", i, num, *next_ptr);
     if (i==60){
        printf("--------------Process finished for Thread 1----------");
        } 
     }
   else {
   if (i==61 || i<=120){ 
     pthread_create(&thread2, NULL, thread_next, &num);
     pthread_join(thread2, &exit_status);
     printf("Threadid 2 processes number %d which is %d and the next higher number is %d\n", i, num, *next_ptr);
     if (i==120){
        printf("--------------Process finished for Thread 2----------");
     }
   }
   else{
   if (i==121 || i<=180){
     pthread_create(&thread3, NULL, thread_next, &num);
     pthread_join(thread3, &exit_status);
     printf("Threadid 3 processes number %d which is %d and the next higher number is %d\n", i, num, *next_ptr);
     if (i==180){
        printf("--------------Process finished for Thread 3----------");
      }
   }
   else{
   if (i==181 || i<=240){
     pthread_create(&thread4, NULL, thread_next, &num);
     pthread_join(thread4, &exit_status);
     printf("Threadid 4 processes number %d which is %d and the next higher number is %d\n", i, num, *next_ptr);
     if (i==240){
        printf("--------------Process finished for Thread 4----------");
     }
   }
   }
   }
   }
   }    
   return 0;
}

OT: What about using `else if`, or `switch`. You save indents and curly brackets doing so, at least. — alk, Mar 19 '13 at 19:07

score 1 · Answer 1 · answered Mar 19 '13 at 16:32

There are some bugs. First of all, you don't initialize next_ptr before printing it.

Next, you share a pointer to the same instance of a variable between 4 threads, without any synchronization mechanism to protect the access to it. You will need to use a critical section or a mutex/semaphore.

score 1 · Answer 2 · answered Mar 19 '13 at 16:36

First, there are somethings you'd want to watch out for:

int i, num, *next_ptr;
...

for(i=1; i<=20; i++)
{
  fscanf(f, "%d", &num);
  ...
  pthread_create(&thread1, NULL, thread_next, &num);

You are sending the same address (&num) to all threads, while reading the number for each thread separately. Since all of them have a pointer to the same number, most likely they are all going to take the last value (or arbitrarily any of their assigned or later values). So as argument, you would need to have as many nums as you have threads.

To return the integer, you can either return the integer cast to a void *, which would work, but it's not entirely standard. One solution would be to provide a place for the return value by the argument:

struct arg_and_return
{
    int num;
    int ret;
};

struct arg_and_return ar;
fscanf(f, "%d", &ar.num);
pthread_create(&thread, NULL, thread_func, &ar);

And within thread, fill in ((struct arg_and_return *)arg)->ret. Of course, still you need as many ars as you have threads.

score 1 · Answer 3 · answered Mar 19 '13 at 16:47

You should not return a pointer to a variable that is local to your thread function, as next is in your code. The reason is pretty much the same as for any other function -- the variable's lifetime is over when the function exits (when the thread terminates), so a pointer to it is unreliable. Instead, try one of the following:

Use a variable from main and pass its address to your thread function when you start it, then modify it from the thread (but don't touch it from outside the thread while the thread is still running, unless you use a mutex).

Or, dynamically allocate the int in the thread and return a pointer to it; you would then free it from your main thread when you're done with it.

Or, if you're sure the representations are compatible, you can cast the int to be returned to a pointer type and return it, then cast back to int in your main thread. This is a common approach, but you need to be sure that it works on your system (it usually does if pointers are at least as large as ints, but you shouldn't take for granted that it will).

Returning single integer value from thread

3 Answers3