Operating System

Operating System - Assignment II Mutex locks and semaphores, as discussed in class, are different techniques to solve the race condition and to ensure an efficient synchronization between cooperating threads and processes. In this assignment, you will use locks and semaphores to solve several synchronization problems between cooperating threads. You can develop the required work either on your computer or on the Ubuntu VM you installed, and you can use any Java IDE you find appropriate (e.g., NetBeans, Eclipse, IntelliJ). Follow the video posted on D2L; in this video, you will create a new Java program and package before you copy a number of .java files to your project. This video shows how to use mutex lock and semaphore between cooperating threads. As discussed and shown in the video, it is important to note that:

• Mutex Lock, in literature, uses acquire() and release(). However, in the standard library of Java, these functions are lock() and unlock(), respectively. The same functionalities but with different names.

• Semaphore, in literature, uses wait() and signal(). However, in the standard library of Java, these functions are acquire() and release(), respectively. The same functionalities but with different names.

Task description:

The files (named question1, question2, and question3) are for three different synchronization problems, with a full Java skeleton. The comments in the Java files explain in detail the required functionalities and guide you to where exactly you should place your implementation, read them carefully before starting coding. DO NOT CHANGE any already existing code (e.g., function name, variable name).

• In the first question, the deposit and withdraw functions share a bank account to add a certain amount or subtract a certain amount from the balance, respectively. Use semaphore(s) to implement the synchronization.

• • In the second question, the producer and consumer functions share an array of integer values to add items

or remove items from the buffer, respectively. Use mutex lock(s) to implement the synchronization. • • In the third question, the Ascending and Descending functions share an array of integer values to sort

them in ascending or descending order, respectively. Use either mutex lock(s) or semaphore(s) to implement the synchronization. Implement the sorting method you find appropriate (e.g., selection sort, bubble sort, insertion sort), but don’t use collection methods/APIs (e.g., Arrays.sort).

Note: the threads running the above questions are implemented to run in an infinite loop, so at some point, you may need to force-stop the program.

Submission:

1. This is an individual assignment -- Cheating/plagiarism will be checked and will receive zero. 2. Your submission to the folder titled Assignment 2 under the D2L Assignments tab contains the following:

a. The three java files you worked on b. One Runtime.pdf: - For each of the three java files, copy the full java code and add a

clear screenshot of the output after running the code. * these are separate files within your submission, don’t submit a zip file

3. The assignment is due October 21st – 11:59pm. You can submit your assignment within 24 hours

after this due date to be graded out of 50% of the assignment’s grade. After this grace period, your late submission will not be accepted.