Assignment "Implement the readers-writers problem using mutex locks in C or C++. Your program should simulate the behavior of the readers, writers, and the shared resource, and it should ensure that no deadlock or starvation occurs." The readers-writers problem is a classic synchronization problem that involves multiple readers and writers accessing a shared resource. The problem is to ensure that the readers and writers can access the resource concurrently, but that no writer is allowed to write to the resource while it is being read by a reader. In this assignment, you will be asked to implement a program in C or C++ that simulates the behavior of the readers, writers, and the shared resource. Your program should use mutex locks to synchronize the access to the shared reseurce. Here are the steps you should follow to complete this assignment: 1. Familiarize yourself with the readers-writers problem and the various approaches that have been taken to solve it. 2. Design a solution to the problem using mutex locks. Your solution should ensure that no deadlock or starvation occurs, 3. Implement your solution in C or Ct+. You can use threads or processes to simulate the behavior of the readers and writers. 4. Test your program with different configurations to ensure that it works correctly. 5. Write a report on your solution to the readers-writers problem, in your report, discuss the design of your solution and how it ensures that no deadlock or starvation occurs. Here is a sample reader A reader is a process or thread that reads data from a shared resource. Here is an example of a reader in C++: Following code shows a simple reader, acquires the mutex lock before reading data from the shared resource. This ensures that no other process or thread can write to the resource while the reader is accessing it. After reading the data, the reader releases the mutex lock and processes the data. Note that this is just one possible implementation of a reader. The exact implementation may vary