Page History

volatile int a, b;

/* Lock to enable threads to access a and b safely */
pthread_mutex_t global_lock = PTHREAD_MUTEX_INITIALIZER|BB. Definitions#data race].


h2. Noncompliant Code Example

In this noncompliant code example the {{worker}} thread is doing something as simple as swapping {{a}} and {{b}} repeatedly.

This code uses one lock. The {{init_lock}} mutex is used to ensure that the worker thread is initialized safely, because the worker thread notifies the main thread once it has set its cancellation policy. 

{code:bgColor=#ffcccc}
/* We need no mutex on these variables. They are initiailized by the main thread,
   then managed exclusively by the worker thread. Finally after the worker thread
   is cancelled, they are once again accessed by the main thread. */
volatile int a, b;

/* Lock to enable worker thread to initialize safely */
pthread_mutex_t init_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t init_lock_sig = PTHREAD_COND_INITIALIZER;

void cleanup_worker_thread(void* dummy) {
  int result;
  if ((result = pthread_mutex_unlock(&global_lock)) != 0) {
    /* handle error */
  }
}

void* worker_thread(void* dummy) {
  int i, c;
  int result;

  /* setSet the cancelability flag duringwhile mutex. */
  /* this guarantees this block calls after pthread_cond_wait() and, more importantly, before pthread_cancel() *holding init lock. */
  if ((result = pthread_mutex_lock(&init_lock)) != 0) {
    /* handleHandle error */
  }
  if ((result = pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,&i)) != 0) {
    /* handleHandle error */
  }
  pthread_cleanup_push( cleanup_worker_thread, NULL);
  if ((result = pthread_cond_signal(&init_lock_sig)) != 0) {
    /* handleHandle error */
  }
  if ((result = pthread_mutex_unlock(&init_lock)) != 0) {
    /* handleHandle error */
  }

  while (1) {
    if ((result = pthread_mutex_lock(&global_lock)) != 0) {
      /* handle error */
    }
    c = b;
    b = a;
    a = c;
    if ((result = pthread_mutex_unlock(&global_lock)) != 0) {
      /* handle error */
    }

    /* now we're safe to cancel, creating cancel point */
    pthread_testcancel();
  }
  pthread_cleanup_pop( 1);
  return NULL;
}


int main(void) {
  int result;
  a = 5;
  b = 10;
  pthread_t worker;

  /* Creates thread while init_lock is held. This guarantees that we
     don't continue until worker thread is safely initialized. */
  if ((result = pthread_mutex_lock(&init_lock)) != 0) {
    /* handleHandle error */
  }
  if ((result = pthread_create( &worker, NULL, worker_thread, NULL)) != 0) {
    /* handleHandle error */
  }

  /* wait until canceltype is set */
  if ((result = pthread_cond_wait( &init_lock_sig, &init_lock)) != 0) {
    /* handleHandle error */
  }
  if ((result = pthread_mutex_unlock(&init_lock)) != 0) {
    /* handleHandle error */
  }

  /* do.. Do stuff, like data input */
  getc(stdin);
  /* since we don't know when the character is read in, the program could continue at any ...meanwhile worker thread runs for some time */
  if ((result = pthread_cancel(worker)) != 0) {
    /* handleCancel error */
  }

  /* pthread_join waits for the thread worker thread, and wait for it to finish up before continuing */
  if ((result = pthread_joincancel(worker, 0)) != 0) {
    /* handleHandle error */
  }

  if ((result = pthread_mutex_lock(&global_lockjoin(worker, 0)) != 0) {
    /* handleHandle error */
  }

  printf("a: %i | b: %i\n", a, b);
  if ((result = pthread_mutex_unlock(&global_lock)) != 0) {
    /* handle error */
  }
  /* this willa should always printbe either "a: 5 | b: 10" or "a: 10 | b: 5" different from b */

  /* cleanClean up */
  if ((result = pthread_mutex_destroy(&init_lock)) != 0) {
    /* handleHandle error */
  }
  if ((result = pthread_cond_destroy(&init_lock_sig)) != 0) {
    /* handleHandle error */
  }
  return 0;
}