Question

I want to write a C++ program which starts 2 threads.

The first thread periodically generates a random number and adds it to the total.

The second thread periodically generates a random number and subtracts it from the total.

The main thread periodically monitors the value of the total. if the total exceeds the maximum value, the program terminates and alerts the user that the maximum has been exceeded. If the total undercuts the minimus value, the program terminates and alerts the user that the minimum has been undercut.

Requirements:

1. The program should be configured at startup via a configuration file. Parameters that should be configurable are:

- minimum and maximum values for the random number generation

- minimum and maximum, values for the total

- period for addition

- period for subtraction

- period for monitoring

2. The program should follow object-oriented design practices.

3. Use only the standard template library classes in your design(i.e. no third party libraries such as boost).

Answer 1

/** add_thread() sub_thread() are thread functions to add and subtract from total which is a global variable.
* MAXTOT and MINTOT are upper and lower limits which if the total crosses the program will terminate
* lockTotal is the mutex to update total atomically
* main function starts the threads
*/
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

#define MAXTOT 10000 //Maximum total allowed after which program terminates
#define MINTOT 100 //Minimum total allowed below which program terminates
int total=1000; //Global variable storing total

pthread_mutex_t lockTotal; //Mutex lock to update the total variable atomically

//Thread for adding to total
void *add_thread(void *arg)
{
    printf("Started add_thread()\n");
   while(1){
       printf("add_thread(): total - %d\n", total);
       pthread_mutex_lock(&lockTotal); // mutex lock
       if(total > MAXTOT || total < MINTOT)// check if total has moved beyond the lower or higher limit
           pthread_exit(NULL);
       total = total + rand(); // add ramdon number to total
       pthread_mutex_unlock(&lockTotal); // mutex unlock
   }  
}

//Thread for subtracting from total
void *sub_thread(void *arg)
{
    printf("Started sub_thread()\n");
   while(1){
       printf("sub_thread(): total - %d\n", total);
       pthread_mutex_lock(&lockTotal); // mutex lock
       if(total > MAXTOT || total < MINTOT) // check if total has moved beyond the lower or higher limit
           pthread_exit(NULL);
       total = total - rand(); // subtract ramdon number from total
       pthread_mutex_unlock(&lockTotal); // mutex unlock
   }
}

int main()
{

        pthread_t addthread, subthread;
        int ret;

       pthread_mutex_init(&lockTotal,0); //Initialize mutex
      
        printf("In main: creating threads\n");
        ret = pthread_create(&addthread, NULL, &add_thread, NULL);
        if(ret != 0) {
                printf("Error: pthread_create() for add failed\n");
                exit(EXIT_FAILURE);
        }
      
       ret = pthread_create(&subthread, NULL, &sub_thread, NULL);
        if(ret != 0) {
                printf("Error: pthread_create() for sub failed\n");
                exit(EXIT_FAILURE);
        }
      
       pthread_mutex_destroy(&lockTotal);
        pthread_exit(NULL);
}