Question

C PROGRAM:

In this assignment, you will use the concept of POSIX threads, semaphores and mutex locks.

Consider a very small bank: XYZ. This bank has only one cashier (aka bank teller or customer representative) and a small waiting room for any incoming customers while the cashier is busy with other customer. There is a sofa which can only hold 5 people at maximum. The cashier can only serve one customer at any time. When the cashier is serving one customer, other customers have to wait in the sofa. If there are already 5 people waiting for their turn and the sixth person comes to the bank, then he/she just leaves the bank. Before the customer is being served, the customer needs to enter the account number and each customer will be serviced on first come first served basis.

Use separate Pthreads to create N customers and cashier. Each of these customers as well as the cashier should run as a separate thread. When the customer is being serviced, print the message clearly saying that the customer with account number <give_account_number_here> is being serviced. Assume each customer is done in 5 seconds. You also need to display the waiting list when the customers comes in and when the customer is serviced. You need to display if any customer leaves the bank without getting service (due to the limit of 5 people already waiting). If there is no customer at any time, the cashier just waits for the arrival of customer.

Answer 1

ANSWER:

This is the classic producer-consumer problem in Computer science.
I will provide the generic solution for this problem which can be easily taken for this banking problem as well. The count of producer and consumer are made 5 as 5 people can be served at max. I have added comments inside the program to understand it at every step. It uses some of C++14, so please compile in g++14 5.3.0 or below version.

/*PLEASE FIND BELOW COMPILABLE PROGRAM. COPY-PASTE THE BELOW PROGRAM AND RUN TO GET OUTPUT.*/

#include<iostream>
#include<stdio.h>
#include<pthread.h>
#include<bits/stdc++.h>
#include<unistd.h>

using namespace std;

pthread_mutex_t the_mutex;//mutex to protect buffer from race conditions
int size = 5;//buffer size
int cnt = 5;//number of producers and consumers
int buffer[5];//buffer on which producer and consumer operate
int in = 0;//index used by producer
int out = 0;//index used by consumer

class semaphore{//implentation of counting semaphore using mutex and condition variable
private:
std::mutex mutex_;//mutex to lock count
std::condition_variable condition_;//condition variable for threads to wait on
int count_;//counter for semaphore

public:
   semaphore(int count_){
       this->count_=count_;//initialise count_ variable
   }

void notify() {
std::unique_lock<decltype(mutex_)> lock(mutex_);//lock mutex for count variable
++count_;//increase count_
if(count_<=0){//if threads are still waiting on this condition
   condition_.notify_one();//notify one of them
}
}

void wait() {
std::unique_lock<decltype(mutex_)> lock(mutex_);//lock mutex for count variable
--count_;//decrease count_
if(count_<0){//if thread can't be run now
   condition_.wait(lock);//wait on the condition
}
}
};

semaphore notEmpty(0);//counting semaphore for consumer to wait for not empty condition
semaphore notFull(size);//counting semaphore for producer to wait for not full condition

void* producer(void *ptr) {
   for(int i=1;;++i){
      notFull.wait();//wait for buffer to be not full
   pthread_mutex_lock(&the_mutex);//protect buffer
   buffer[in] = i;//insert item
   in = (in+1)%size;
   cout<<"Customer-"<<i<<" came and waiting to be serviced."<<endl;
   pthread_mutex_unlock(&the_mutex);//release the buffer
   notEmpty.notify();//notify consumer that buffer is not empty
   }
pthread_exit(0);
}

void* consumer(void *ptr) {
   for(int i=1;;++i){
       notEmpty.wait();//wait for buffer to be not full
       pthread_mutex_lock(&the_mutex);//protect buffer
       int item = buffer[out];//remove item
       out = (out+1)%size;
       cout<<"Customer with account number-"<<item<<" is being serviced."<<endl;
       pthread_mutex_unlock(&the_mutex);//release the buffer
       notFull.notify();//notify producer that buffer is not full
   }
   pthread_exit(0);
}

int main() {
   //Define Threads and Mutexes
   pthread_t pro, con;
   pthread_mutex_init(&the_mutex, NULL);

   //Create the threads
   pthread_create(&con, NULL, consumer, NULL);
   sleep(1);
   pthread_create(&pro, NULL, producer, NULL);

   //Join Threads
   pthread_join(con, NULL);
   pthread_join(pro, NULL);

   //Destroy Mutexes
   pthread_mutex_destroy(&the_mutex);
   return 0;
}

/*To RUN THE PROGRAM, USE THE BELOW COMMAND LINE PARAMETER. PLEASE NOTE THAT AN ADDITIONAL PARAMETER IS REQUIRED IN COMMAND LINE TO COMPILE AS IT USES PTHREAD.*/

g++ test.cpp -pthread

PLEASE FIND BELOW SNAPSHOT OF RUNNING CODE:

P.S. I hope the answer is as expected. Please comment if anything additional is required.