Question

Code in C++

Modify “Producer and Consumer Problem” from lecture note so that it can use all buffer space, not “buffersize – 1” as in the lecture note. This program should work as follows:

1.The user will run the program and will enter two numbers on the command line. Those numbers will be used for buffersize and counter limit.

2. The program will then create a separate threads, producer and consumer thread.

3. Producer thread generates a random number through random number generator

function and inserts this into buffer and prints the number. Increment counter.

4. Consumer thread goes to the buffer and takes a number in the proper order and

prints it out. Increment counter.

5. After counter reaches its limit, both threads should be terminated and return to main.

6. Main program terminates.

7. You can implement this project in any OS environment of your choice, windows, linux, etc. Also you can use any programming languages you want but your program and sample run should clear show that you implemented subtasks using separate threads.

Answer 1

Screen shorts of program:

Sample output:

Code to copy:

#include<iostream>

#include <thread>

#include <stdlib.h>

#include<time.h>

#include <sstream>//char* to int convertion

#include <mutex>

#include <chrono>

#include <condition_variable>

using namespace std;

int *buffer, bufferSize = 0, counter = 0;

int counterLimit;

std::mutex mut, cout_mut;

std::condition_variable condition;

int n = 0;//n for number of elements in buffer

//remove data from buffer

int remove()

{

     while (true)

     {

          std::unique_lock<std::mutex> lock(mut);

          condition.wait(lock, []{return n > 0;});

          //remove data from buffer

          int back = buffer[--n];

          //unlock mutex

          lock.unlock();

          condition.notify_all();

          return back;

     }

}

//insert data into buffer

void insert(int data)

{

     while (true) {

          std::unique_lock<std::mutex> lock(mut);

          condition.wait(lock, []{return n < bufferSize;});

          //add data into buffer

          buffer[n]=data;

          n++;

          //unlock mutex

          lock.unlock();

          condition.notify_all();

          return;

     }

}

void producer()

{

     //After counter reaches its limit, both threads should be terminated

     while(counter<counterLimit)

     {

          //generates a random number

          int data = std::rand() % 10;

          //inserts this into buffer

          insert(data);

          cout_mut.lock();

          //prints the number.

          std::cout << "Producer has produced data: " << data << std::endl;

          std::this_thread::sleep_for(std::chrono::milliseconds(50));

          cout_mut.unlock();

          //Increment counter

          counter++;

     }// Use current time as seed for random generator

    

}

void consumer()

{   

     //After counter reaches its limit, both thread should be terminated

     while(counter<counterLimit)

     {

          //takes a number in the proper order

          int data = remove();

          cout_mut.lock();

          //prints data

          std::cout << "Consumer has consumed data: " << data << std::endl;

          std::this_thread::sleep_for(std::chrono::milliseconds(50));

          cout_mut.unlock();

          //increament counter

          counter++;

     }

}

int main(int argc, char *argv[])

{

     if (argc <= 2)

     {

          cout<<" No Extra Command Line Argument Passed. Enter two numbers on the command line ";

          return 0;

     }

     istringstream iss(argv[1]);

     //set buffersize

     iss>> bufferSize;

     istringstream is(argv[2]);

     //set counter limit

     is >> counterLimit;

     //Initialise buffer

     buffer = new int[bufferSize];

     //create thread for producer

     thread threadProducer(producer);

     //create thread for consumer

     thread threadConsumer(consumer);

     // Wait for the threads to finish

     // Wait for thread t1 to finish

     threadProducer.join();

     // Wait for thread t2 to finish

     threadConsumer.join();

     //system("pause");

     return 0;

}