Synchronization primitives: Mutex and Semaphore (Sample Program) - Article 9

Hi Folks,

In this article, I am going to present my version of producer consumer problem which we need to synchronize.

The producer can produce a maximum of 5 elements and the consumer consumes 1 element at a time. All data is shared and hence, synchronization is needed. In this article, I am going to present the program. In the next article, we shall apply synchronization.

#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/sem.h>
#include<pthread.h>
#include<stdio.h>
#include<stdlib.h>

 typedef struct node {
    struct node *link;
    int data;
} NODE;

 static int count = 0;

 NODE *head = NULL;

 NODE *get_node(void) {
    int data = rand();
    data = data % 13;
    NODE *ptr = (NODE *)malloc(sizeof(NODE));
    if(ptr != NULL) {
        ptr->data = data;
        ptr->link = NULL;
    }
    return ptr;
}

 void print_node(NODE *ptr) {
    printf("|%d|",ptr->data);
    if(ptr->link != NULL) {
        printf("->");
    }
}

 void display(void) {
    NODE *ptr = head;

     if(head == NULL) {
        printf("List is empty\n");
        return;
    }

     while(ptr != NULL) {
        print_node(ptr);
        ptr = ptr->link;
    }
    printf("\n");
}

 void *producer(void *p) {
    NODE *temp;
    NODE *ptr;

     while(1) {
        if(count >= 5) {
            printf("The list is full\n");
            continue;
        }
        temp = get_node();
        ptr = head;
        if(head == NULL) {
            head = temp;
            count++;
            printf("Count: %d\n",count);
            continue;
        }

         while(ptr->link != NULL)
            ptr = ptr->link;

         ptr->link = temp;
        count++;
        printf("Count: %d\n",count);
        display();
    }
}

 void *consumer(void *p) {
    NODE *temp;

     while(1) {
        temp = head;
        if(head == NULL) {
            printf("Nothing to delete\n");
            printf("Count: %d\n",count);
            continue;
        }
        head = head->link;
        free(temp);
        count--;
        printf("Count: %d\n",count);
        display();
    }
}

 void main() {
    pthread_t tid1, tid2;
    pthread_create(&tid1, NULL, producer, NULL);   
    pthread_create(&tid2, NULL, consumer, NULL);
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
}

Comments

Post a Comment

Popular posts from this blog

Synchronization primitives: Mutex and Semaphore (Serialization & Mutex problems using Semaphore) - Article 6

Hi Friends, In the previous articles, we have gained knowledge about Mutex and Semaphore. In this article, we shall see how a Semaphore can be used to solve serialization problem and Mutual Exclusion (Mutex) problem. Serialization problem: Thread 1: Event A; // Could be any code Thread 2: Event B; // Could be any code The problem is, we have to ensure that Event B or a particular code or instructions should always be executed after Event A or some other particular code. Basically, we are serializing the instructions irrespective of how the threads are scheduled to run. Solution: There are no resources here, we need to just signal, initialize Semaphore to 0. Semaphore SignalThread2 = 0; Thread 1: Event A; SignalThread2.signal(); Thread 2: SignalThread2.wait(); Event B; The code for Thread 1 and Thread 2 is as above. Irrespective of which thread is scheduled, Event A always occurs before Event B. How? Let's say Thread 2 is scheduled first, it executes
Read more

Synchronization primitives: Mutex and Semaphore (Readers & Writers problem) - Article 8

Hi Friends, In this article, we shall solve the Readers & Writers problem. Readers & Writers problem: There may be m writers & n readers related to a shared data structure or a record in the database (some shared data). Only one writer thread can be updating the data, but there can be many readers accessing the data. The constraints are: 1. Any number of readers can be accessing the data in critical section. 2. Only one writer thread should be allowed to update the data in critical section. Solution: int readers = 0; // Shared variable to keep track of number of readers,                  // yes this also needs to be protected Semaphore readersProtect = 1; Semaphore roomEmpty = 1; Writers thread code: roomEmpty.wait();     // Update shared data, critical section for writers roomEmpty.signal(); Readers thread code: readersProtect.wait();     readers = readers + 1;     if(readers == 1)         roomEmpty.wait(); // First reader locks and bars wri
Read more

Copy constructor in C++ (Part 2)

Now, the important question comes is regarding the signature of copy constructor. That is, why copy constructor takes a reference as parameter. Let's copy by value from previous example. CopyDemo(const CopyDemo obj) {     ptr = new int;     *ptr = *obj.ptr; } Now from main(), CopyDemo o2 = o1; Let me explain in detail. We have called copy constructor to copy o1 to o2. But, since we are passing by value, first o1 has to be copied to obj. So internally, statement will be, const CopyDemo obj = o1; Now, what happens is again copy constructor is invoked. Already, we can sense some problem, copy constructor is called again. Internally, the statement is repeated again. const CopyDemo obj = o1; This goes into a recursive loop and following statements get repeated till stack overflow happens and ultimately program crashes. const CopyDemo obj = o1; const CopyDemo obj = o1; const CopyDemo obj = o1; . . .
Read more