• Threads:
  • A mechanism that permits a single process to perform multiple tasks concurrently
• Shared Variables:
  • Threads share the initialized data, uninitialized data, and heap segments
  • Threads share signal dispositions

• The Good:
  • Because threads share the "global" data segments it is easy for them to share information
• The Bad:
  • Because threads share signal dispositions it is very hard to use signals to have one thread notify another that a shared variable has changed value

• The General Idea:
  • Have one thread poll (i.e., repeatedly check, perhaps with a small delay to see if the variable has changed)
• The Downsides:
  • Polling wastes CPU time

unixexamples/conditionvariables/tax1.c

        #include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "tax_lib.h"

static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static int should = -1;         // Shared variable

static void
*thread_entry(void *arg)
{
  pthread_mutex_lock(&mutex);

  // Start of critical section
  if (should_tax()) should = 1;
  else              should = 0;
  // End of critical section
  
  pthread_mutex_unlock(&mutex);
  
  record_status(); // This takes a long time

  return NULL;
}

int
main(void)
{
  float       rate, sales, tax;
  int         waiting;
  pthread_t   helper;
  void        *result;

  pthread_create(&helper, NULL, thread_entry, NULL);
  
  rate = 0.05;
  sales = total_sales();

  waiting = 1;
  while (waiting) // Poll until the helper thread is done
    {
      pthread_mutex_lock(&mutex);
      // Start of critical section
      if (should != -1) waiting = 0;
      // End of critical section
      pthread_mutex_unlock(&mutex);
    }

  // Start of critical section
  if (should) tax = sales * rate;
  else        tax = 0.0;
  // End of critical section
  
  printf("Tax: %5.2f\n", tax);
  pthread_join(helper, &result);
  exit(0);
}
        

• Polling:
  • Must ensure that access is mutually exclusive (e.g., using a mutex)
• Any Other Mechanism:
  • Is likely to have the same requirement

• The Mechanism:
  • pthread_cond_t variables
• Actions:
  • Block until notified
  • Unblock a single (arbitrary) thread
  • Unblock all threads

• Step 1 - Allocation:
  • Allocate memory for the condition variable either statically in the initialized data segment, automatically (on the stack), or dynamically (on the heap)
• Step 2 - Initialization:
  • Assign attributes to the condition variable

• Static Allocation and Initialization:
  • static pthread_cond_t example = PTHREAD_COND_INITIALIZER
• Dynamic Initialization:
  • Must be used for condition variables that are dynamically allocated (on the heap) or automatically allocated (on the stack)
  • Can be used for condition variables that are statically allocated when non-default attributes are needed

• Entities:
  • Each condition variable has a predicate (i.e., a Boolean-valued expression) involving one or more associated shared variables
  • Each condition variable has an associated mutex
• Threads:
  • The blocking thread(s)
  • The notifying thread(s)

• The Blocking Thread:

  • 	  acquire the mutex
              while (predicate) block on the condition variable
    	  when notified use the shared variable
    	  relinquish the mutex  
    	  

• The Notifying Thread:

  • 	  acquire the mutex
    	  use the shared variable
    	  relinquish the mutex  
              notify
    	  

• Setup:
  • Obtain the mutex
  • While the shared variable is in the wrong state, atomically relinquish the mutex and block on the condition variable
• Upon Notification:
  • Obtain the mutex
  • Use the shared variable
  • Relinquish the mutex

When Called: mutex is relinquished and the calling thread is blocked.

When Unblocked: mutex is obtained (so that the shared variable can be used).

• Why Use a Loop?
  • pthread_cond_wait() returns when notified but there is no guarantee that the predicate is satisfied so it must be re-checked
• Why Wouldn't the Predicate be Satisfied?
  • Other threads may have been notified, acquired the mutex first and used the shared variables
  • Spurious notification (though rare) can occur (and are permitted for efficiency reasons)

• Notifying A Single (Arbitrary) Blocked Thread:
  • Is more efficient
  • Is only appropriate when it doesn't matter which thread is notified (e.g., when all of the blocking threads perform the same task)
• Notifying All Blocking Threads:
  • Is less efficient
  • Should always yield correct results since all blocking threads should be able to handle redundant and/or spurious notifications

Note: All blocking threads will be notified but which one(s) are scheduled is arbitrary.

unixexamples/conditionvariables/tax2.c

        #include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "tax_lib.h"

static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t  cv    = PTHREAD_COND_INITIALIZER;
static int should = -1;         // Shared variable

static void
*thread_entry(void *arg)
{
  pthread_mutex_lock(&mutex);

  // Start of critical section
  if (should_tax()) should = 1;
  else              should = 0;
  // End of critical section
  
  pthread_mutex_unlock(&mutex);

  pthread_cond_broadcast(&cv);
  
  record_status(); // This takes a long time

  return NULL;
}



int
main(void)
{
  float       rate, sales, tax;
  pthread_t   helper;
  void        *result;

  pthread_create(&helper, NULL, thread_entry, NULL);
  
  rate = 0.05;
  sales = total_sales();

  pthread_mutex_lock(&mutex);

  while (should == -1)
    {
      pthread_cond_wait(&cv, &mutex);
    }
  
  if (should) tax = sales * rate;
  else        tax = 0.0;

  pthread_mutex_unlock(&mutex); // Not necessary for this example
  
  printf("Tax: %5.2f\n", tax);
  pthread_join(helper, &result);
  exit(0);
}
        

• Which Condition Variables?
  • Those that are automatically or dynamically allocated
• When?
  • When no threads are waiting on it
  • Before freeing the memory (for dynamically allocated) or before the "host function" returns (for automatically allocated)