Page History

#include <threads.h>
#include <stdlib.h>

/* Global key to the thread-specific storage */
tss_t key;
enum { MAX_THREADS = 3 };

int *get_data(void) {
  int *arr = (int *)malloc(2 * sizeof(int));
  if (arr == NULL) {
    return arr;  /* Report error  */
  }
  arr[0] = 10;
  arr[1] = 42;
  return arr;
}

int add_data(void) {
  int *data = get_data();
  if (data == NULL) {
    return -1;	/* Report error */
  }

  if (thrd_success != tss_set(key, (void *)data)) {
    /* Handle error */
  }
  return 0;
}

void print_data(void) {
  /* Get this thread's global data from key */
  int *data = tss_get(key);

  if (data != NULL) {
    /* Print data */
  } 
}

int function(void *dummy) {
  if (add_data() != 0) {
    return -1;	/* Report error */
  }
  print_data();
  return 0;
}

int main(void) {
  thrd

#include <pthread.h>
#include <stdio.h>
#include<malloc.h>

#define MAX_NUMBER_OF_THREADS 3

/* function prototypes */
void destructor(void * data);
void* function();
void add_data();
void print_data();


/* global key to the thread specific data */
pthread_key_t key;

int main( void )
{
    int i;
    pthread_t thread_id[MAX_NUMBER_OF_THREADS];

     /* createCreate the thread specific data key before creating the threads */
    pthread_key  if (thrd_success != tss_create( &key, NULL );

   )) {
    /* Handle error */
  }

  /* createCreate threads that willwould usestore thespecific keystorage */
     for (size_t i = 0; i < MAX_NUMBER_OF_THREADS; i++) {
        pthread    if (thrd_success != thrd_create( &thread_id[i], NULL, function, NULL );
   )) {
      /* Handle error */
    }
  }

     for (size_t i = 0; i < MAX_NUMBER_OF_THREADS; i++) {
           int ret if (thrd_success != pthreadthrd_join(thread_id[i], NULL);
        printf("Join return value for thread[%d] = %d",i,ret);
   ) {
      /* Handle error */
    }
  }

     pthread_keytss_delete(key);
  return 0;
}

#include <threads.h>
#include <stdlib.h>
 
/* Global key Gettingto somethe randomthread-specific datastorage */
tss_t key;
 
int *getfunction(void *dummy) {
  if (add_data()
) != 0) {
       intreturn *arr = malloc(2*sizeof(int));
    *arr = rand-1;	/* Report error */
  }
  print_data();
    *(arr+1) = rand(  free(tss_get(key));
     return arr0;
}

/* ... Other functions are unchanged */

#include <threads.h>
#include <stdlib.h>

/* Global key to the thread-specific storage */
tss_t key;
enum { MAX_THREADS = 3 };

/* ... Other functions are unchanged */

void destructor(void *data) {
  free(datavoid *function(void)
{
    add_data();
    print_data();
    pthread_exit(NULL);
}
 
voidint add_datamain(void)
 {
    int *data = get_data();
    printf("some data = %p\n",data);
    pthread_setspecific( key,
    (void *) data);
}
void print_data()
{
    /* get this thread's global data from
    * priority_key */
    int *data = pthread_getspecific(
    key );
    printf("thread id = %u, data[0] = %d, data[1] = %d \n",(size_t)pthread_self(),*data,*(data+1));
}
 

thrd_t thread_id[MAX_THREADS];

  /* Create the key before creating the threads */
  if (thrd_success != tss_create(&key, destructor)) {
    /* Handle error */
  }

  /* Create threads that would store specific storage */
  for (size_t i = 0; i < MAX_THREADS; i++) {
    if (thrd_success != thrd_create(&thread_id[i], function, NULL)) {
      /* Handle error */
    }
  }

  for (size_t i = 0; i < MAX_THREADS; i++) {
    if (thrd_success != thrd_join(thread_id[i], NULL)) {
      /* Handle error */
    }
  }

  tss_delete(key);
  return 0;
}