Question

When using pthread, I can pass data at thread creation time.

What is the proper way of passing new data to an already running thread?

I’m considering making a global variable and make my thread read from that.

Thanks

Answer 1

That will certainly work. Basically, threads are just lightweight processes that share the same memory space. Global variables, being in that memory space, are available to every thread.

The trick is not with the readers so much as the writers. If you have a simple chunk of global memory, like an int, then assigning to that int will probably be safe. Bt consider something a little more complicated, like a struct. Just to be definite, let’s say we have

struct S { int a; float b; } s1, s2;

Now s1,s2 are variables of type struct S. We can initialize them

s1 = { 42,  3.14f };

and we can assign them

s2 = s1;

But when we assign them the processor isn’t guaranteed to complete the assignment to the whole struct in one step — we say it’s not atomic. So let’s now imagine two threads:

thread 1:
   while (true){
      printf("{%d,%f}\n", s2.a, s2.b );
      sleep(1);
   }

thread 2:
   while(true){
      sleep(1);
      s2 = s1;
      s1.a += 1;
      s1.b += 3.14f ;
   }

We can see that we’d expect s2 to have the values {42, 3.14}, {43, 6.28}, {44, 9.42} ….

But what we see printed might be anything like

 {42,3.14}
 {43,3.14}
 {43,6.28}

or

 {43,3.14}
 {44,6.28}

and so on. The problem is that thread 1 may get control and “look at” s2 at any time during that assignment.

The moral is that while global memory is a perfectly workable way to do it, you need to take into account the possibility that your threads will cross over one another. There are several solutions to this, with the basic one being to use semaphores. A semaphore has two operations, confusingly named from Dutch as P and V.

P simply waits until a variable is 0 and the goes on, adding 1 to the variable; V subtracts 1 from the variable. The only thing special is that they do this atomically — they can’t be interrupted.

Now, do you code as

thread 1:
   while (true){
      P();
      printf("{%d,%f}\n", s2.a, s2.b );
      V();
      sleep(1);
   }

thread 2:
   while(true){
      sleep(1);
      P();
      s2 = s1;
      V();
      s1.a += 1;
      s1.b += 3.14f ;
   }

and you’re guaranteed that you’ll never have thread 2 half-completing an assignment while thread 1 is trying to print.

(Pthreads has semaphores, by the way.)