The following readerwriter algorithm works for multiple readers and a$-$

single writer. It allows reading of the shared variables x$1$and x$2$into local

variables d$1$and d$2$without locking, thus not blocking the writer.

Before writing to the shared variables x$1$and x$2,$the writer increments a

counter c$.$It then proceeds to write to the variables, and finally increments

c again. The two increments of c ensure that it is odd when the process

is writing to the variables, and even otherwise. Hence, when a reader

wishes to read the shared variables, it waits in a loop until c is even before

reading them. Also, before returning it checks that the value of c has not

changed i$(.$e$.,$another write has not begun$).$If it has changed, the process

starts over. This ensures the pair of values read corresponds to a single

occurrence of a write.

Nonblocking readerwriter$--$

integer c$,$x$1,$x$20$

reader

writer

integer c$0,$d$1,$d$2$

integer d$1,$d$2$

loop forever

loop forever

p$1$: repeat

q$1$: d$1$get$()$

p$2$: repeat

q$2$: d$2$get$()$

p$3$: c$0$c

q$3$: c $$c$+1$

p$4$: until c$(0$mod $2=0)$

q$4$: x$1$d$1$

p$5$: d$1$x$1$

q$5$: x$2$d$2$

p$6$: d$2$x$2$

q$6$: c $$c$+1$

p$7$: until c$(0=$c$)$

q$7$:

p$8$: used$(1,$d$2)$

q$8$:

$1($b $$Extend the algorithm with a third type of process called an incre$)$

menter. An incrementer increments the values of x$1$and x$2,$i$.$e$.,$adds

$11$to them. It is a low priority process and so should not block writers

while reading x$1$and x$2,$and synchronisation mechanisms should give

preference to writers over incrementers.

Implement your algorithm from Question $1($b $$in Java. You should have$)$

$5$reader threads, $5$writer threads and $5$incrementer threads. Each writer

and incrementer waits for a random time between $(0$and $10$milliseconds$)$

then updates the shared variables just once $$and terminates. The writers$()$

can update the variables with random values. The readers wait a random

time between $(0$and $10$milliseconds $$before each read. When all readers$)$

have read the final update, the entire program should terminate gracefully,

i$.$e$.,$all threads should reach the end of their run methods. Your program

should produce output by calling the appropriate methods of the provided

$2$class A$2$Event.java. For testing purposes, it is a requirement that you call

the A$2$Event class every time one of the events occurs. In particular, the

writers and incrementers must call the A$2$Event class before another writer

or incrementer begins to update the results. It is also important that you

do not modify the provided class.

include $4$parts$$

$$Java classes implementing your design

$$Appropriate use of synchronisation mechanisms

$$Program producing correct behaviour

$$readme file

$/**$

$*$ Class A$2$Event

$*$ DO NOT MODIFY THIS CLASS

$*$

$*$ This class is used to print all events happening during the lifetime of your program

$*$

$*$ NOTE : Please make sure that you have called EVERY event method below in your main program

$*$ when ever such an event happens.

$*$ This class will be replaced with a similar class that will validate the program flow

$*$ automatically.

$*$

$*/$

public class A$2$Event $\{$

$/**$

$*$ Call this event method when a reader reads the current data

$*$

$*$ @param reader id $($value between $0$ and $4$ inclusive$)$

$*$ @param x$1($the value of x$1$ read$)$

$*$ @param x$2($the value for x$2$ read$)$

$*$

$*/$

public static void readData$($int reader, int x$1,$ int x$2)\{$

System.out.println$("$Reader #$"+$reader$+"$ has read values: x$1"+$x$1+"$ x$2"+$x$2)$;

$\}$

$/**$

$*$ Call this event method when a writer writes to the data

$*$

$*$ @param writer id $($value between $0$ and $4$ inclusive$)$

$*$ @param int x$1($the value written to x$1)$

$*$ @param int x$2($the value written to x$2)$

$*$

$*/$

public static void writeData$($int writer, int x$1,$ int x$2)\{$

System.out.println$("$Writer #$"+$writer$+"$ has written values: x$1"+$x$1+"$ x$2"+$x$2)$;

$\}$

$/**$

$*$ Call this event method when an incrementer increments the data

$*$

$*$ @param incrementer id $($value between $0$ and $4$ inclusive$)$

$*$ @param int x$1($the incremented value of x$1)$

$*$ @param int x$2($the incremented value of x$2)$

$*$

$*/$

public static void incrementData$($int incrementer, int x$1,$ int x$2)\{$

System.out.println$("$Incrementer #$"+$incrementer$+"$ has incremented values: x$1"+$x$1+"$ x$2"+$x$2)$;

$\}$

$/**$

$*$ Call this event method when all $5$ readers have read the final result

$*$

$*/$

public static void terminateReadWrite$()\{$

System.out.println$("$All readers have read the final data."$)$;

$\}$

$\}```$

$*$ Class A$2$Event

$*$ DO NOT MODIFY THIS CLASS

$*$

$*$ This class is used to print all events happening during the lifetime of your program

$*$

$*$ NOTE : Please make sure that you have called EVERY event method below in your main program

$*$ when ever such an event happens.

$*$ This class will be replaced with a similar class that will validate the program flow

$*$ automatically.

$*$

$*/$

public class A$2$Event $\{$

$/**$

$*$ Call this event method when a reader reads the current data

$*$

$*$ @param reader id $($value between $0$ and $4$ inclusive$)$

$*$ @param x$1($the val