Question

I’ve started experimenting with POSix threads using the ios platform. Coming fro using NSThread it’s pretty daunting.

Basically in my sample app I have a big array filled with type mystruct. Every so often (very frequently) I want to perform a task with the contents of one of these structs in the background so I pass it to detachnewthread to kick things off.

I think I have the basics down but Id like to get a professional opinion before I attempt to move on to more complicated stuff.
Does what I have here seem “o.k” and could you point out anything missing that could cause problems? Can you spot any memory management issues etc….

struct mystruct

{
 pthread  thread;

int a;
long c;

}


void detachnewthread(mystruct *str)
{

   // pthread_t thread;

    if(str)
    {
    int rc;
         // printf("In detachnewthread: creating thread %d\n", str->soundid);
        rc = pthread_create(&str->thread, NULL, DoStuffWithMyStruct, (void *)str);
        if (rc){
            printf("ERROR; return code from pthread_create() is %d\n", rc);
            //exit(-1);
        }

    }

   //
    /* Last thing that main() should do */
   // pthread_exit(NULL);    


}



void *DoStuffWithMyStruct(void *threadid)
{
    mystruct *sptr;
    dptr = (mystruct *)threadid;



  // do stuff with data in my struct
   pthread_detach(soundptr->thread); 

}

Answer 1

One potential issue would be how the storage for the passed in structure mystruct is created. The lifetime of that variable is very critical to its usage in the thread. For example, if the caller of detachnewthread had that declared on the stack and then returned before the thread finished, it would be undefined behavior. Likewise, if it were dynamically allocated, then it is necessary to make sure it is not freed before the thread is finished.

In response to the comment/question: The necessity of some kind of mutex depends on the usage. For the sake of discussion, I will assume it is dynamically allocated. If the calling thread fills in the contents of the structure prior to creating the “child” thread and can guarantee that it will not be freed until after the child thread exits, and the subsequent access is read/only, then you would not need a mutex to protect it. I can imagine that type of scenario if the structure contains information that the child thread needs for completing its task.

If, however, more than one thread will be accessing the contents of the structure and one or more threads will be changing the data (writing to the structure), then you probably do need a mutex to protect it.