The program must use these $2$ threads to communicate with each other using a Producer$-$Consumer approach:

The Producer loop:

while $(1)$

$\{$

pthread$\_$mutex$\_$lock$($&mutex$)$; $//$ Lock the mutex before checking if the buffer has data

while $($count $==$ SIZE$)//$ Buffer is full; Wait for signal that space is available

pthread$\_$cond$\_$wait$($&space$\_$available, &mutex$)$;

put$\_$item$($value$)$; $//$ Space is free, add an item! This will increment int count

pthread$\_$mutex$\_$unlock$($&mutex$)$; $//$ Unlock the mutex

pthread$\_$cond$\_$signal$($&has$\_$data$)$; $//$ Signal consumer that the buffer is no longer empty

$\}$

The Consumer loop:

while $(1)$

$\{$

pthread$\_$mutex$\_$lock$($&mutex$)$; $//$ Lock the mutex before checking if the buffer has data

while $($count $==0)//$ Buffer is empty. Wait for signal that the buffer has data

pthread$\_$cond$\_$wait$($&has$\_$data, &mutex$)$;

value $=$ get$\_$item$()$; $//$ There's an item, get it$!$ This will decrement int count

pthread$\_$mutex$\_$unlock$($&mutex$)$; $//$ Unlock the mutex

pthread$\_$cond$\_$signal$($&space$\_$available$)$; $//$ Signal that the buffer has space

Both threads must share one mutex and two condition variables to control and protect the counting of a number. The number must count from a starting value of $0$ to $10,$ by ones, at which point the program will end. You get to decide which parts of the incrementation and printing go in each thread.

Your variables must be named as follows:

Your mutex must be named "myMutex".

Your two conditions variables must be named "myCond$1"$ and "myCond$2".$

Your counting variable must be named "myCount".

Your program must output lines that contain the following text exactly as written, at the following times. No other lines are allowed to be in the output:

When your program begins:

PROGRAM START

When thread $2$ is created:

CONSUMER THREAD CREATED

When myCount changes value:

myCount: $->$

Example:

myCount: $1->2$

When myMutex is unlocked:

: myMutex unlocked

Example:

CONSUMER: myMutex unlocked

When myMutex is locked:

: myMutex locked

Example:

CONSUMER: myMutex locked

When myCond$1$ or myCond$2$ has pthread$\_$cond$\_$wait$()$ called on it:

: waiting on

Example:

PRODUCER: waiting on myCond$1$

When myCond$1$ or myCond$2$ has pthread$\_$cond$\_$signal$()$ called on it:

: signaling

Example:

CONSUMER: signaling myCond$1$

When your program ends:

PROGRAM END Example Code: #include

#include

#include

$//$ Declaration of thread condition variables

pthread$\_$cond$\_$t myCond$1=$ PTHREAD$\_$COND$\_$INITIALIZER;

pthread$\_$cond$\_$t myCond$2=$ PTHREAD$\_$COND$\_$INITIALIZER;

$//$ Declaration of mutex

pthread$\_$mutex$\_$t myMutex $=$ PTHREAD$\_$MUTEX$\_$INITIALIZER;

$//$ Shared variable

int myCount $=0$;

$//$ Thread function for the producer

void$*$ producer$($void$*$ arg$)\{$

while$(1)\{$

$//$ Lock mutex

pthread$\_$mutex$\_$lock$($&myMutex$)$;

printf$("$PRODUCER: myMutex locked

$")$;

$//$ Check and wait on condition

while$($myCount $==10)\{$

printf$("$PRODUCER: waiting on myCond$2$

$")$;

pthread$\_$cond$\_$wait$($&myCond$2,$ &myMutex$)$;

$\}$

$//$ Critical section

printf$("$myCount: $\%$d $->\%$d

$",$ myCount, myCount$+1)$;

myCount$++$;

$//$ Signal consumer thread and unlock mutex

pthread$\_$cond$\_$signal$($&myCond$1)$;

printf$("$PRODUCER: signaling myCond$1$

$")$;

printf$("$PRODUCER: myMutex unlocked

$")$;

pthread$\_$mutex$\_$unlock$($&myMutex$)$;

$//$ Break if count reached $10$

if$($myCount $>=10)$ break;

$\}$

return NULL;

$\}$

$//$ Thread function for the consumer

void$*$ consumer$($void$*$ arg$)\{$

printf$("$CONSUMER THREAD CREATED

$")$;

while$(1)\{$

$//$ Lock mutex

pthread$\_$mutex$\_$lock$($&myMutex$)$;

printf$("$CONSUMER: myMutex locked

$")$;

$//$ Check and wait on condition

while$($myCount $==0)\{$

printf$("$CONSUMER: waiting on myCond$1$

$")$;

pthread$\_$cond$\_$wait$($&myCond$1,$ &myMutex$)$;

$\}$

$//$ Critical section

printf$("$myCount: $\%$d $->\%$d

$",$ myCount, myCount$-1)$;

myCount$--$;

$//$ Signal producer thread and unlock mutex

pthread$\_$cond$\_$signal$($&myCond$2)$;

printf$("$CONSUMER: signaling myCond$2$

$")$;

printf$("$CONSUMER: myMutex unlocked

$")$;

pthread$\_$mutex$\_$unlock$($&myMutex$)$;

$//$ Break if count reached $0$ again

if$($myCount $<=0)$ break;

$\}$

return NULL;

$\}$

int main$()\{$

pthread$\_$t prod, cons;

printf$("$PROGRAM START

$")$;

$//$ Create producer thread

if$($pthread$\_$create$($&prod, NULL, &producer, NULL$)!=0)\{$

perror$("$Failed to create producer thread"$)$;

return $1$;

$\}$

$//$ Create consumer thread

if$($pthread$\_$create$($&cons, NULL, &consumer, NULL$)!=0)\{$

perror$("$Failed to create consumer thread"$)$;

return $1$;

$\}$

$//$ Wait for threads to finish

pthread$\_$join$($prod$,$ NULL$)$;

pthread$\_$join$($cons$,$ NULL$)$;

printf$("$PROGRAM END

$")$;

return $0$;

$\}$