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. you will use semaphores to  solve a number of synchronization problems between cooperating threads.

important to note that:

•  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.

In  the first question, the deposit and withdraw functions share a bank  account to add certain amount or subtract certain amount from the  balance, respectively. 

Use semaphore(s) to implement the synchronization.

Implent the following to the code, 

1. Implement the deposit functionality method

 Deposit the input amount to the balance only if the current balance is less than 2000$

 Deposit  doesn’t wait until this condition is true (If the condition is false,  skip adding the amount), thus use if statements rather than waiting  while loops

 Call the displayStatus() function after you deposit the amount and before release the lock

2. Implement the withdraw functionality, method

 Withdraw the input amount from the balance only if the current balance is greater than or equal to input amount

 Withdraw  doesn’t wait until this condition is true (if the condition is false,  skip withdrawing the amount), thus use if statements rather than waiting  while  loops

 Call the displayStatus() function after you remove the amount and before release the lock

//Question1_WithdrawDeposit.java file

package Threads_Synchronization;

import java.util.concurrent.Semaphore;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

public class Question1_WithdrawDeposit {

/*

* In this question use semaphore(s) to enable process synchronization

*

* Thread 1 and thread 2 (in the main function) share a single bank account (initial balance of 1000$).

* thread 1 can deposit certain input amount to the balance only if the current balance is less than 2000$

*  thread 2 can withdraw certain input amount from the balance only if the  current balance is greater than or equal to the input amount.

*

*/

// shared resources between thread 1 and thread 2 are:

public static int balance = 1000; //the initial value of the account’s balance

//DONOT CHANGE THIS VARIABLE

// add below any further resources you think the deposit and withdraw threads/functions must share

//——————————————–end of shared resources section

// this function simply displays the current balance of the shared account and which thread made the call

// DONOT CHANGE THIS FUNCTION

public static void displayStatus() {

if(Thread.currentThread().getName().equals(“withdraw”))

System.out.println(“The  withdraw function successfully took the amount and the current value of  the account’s balance is :”+ balance + “$”);

else

System.out.println(“The  deposit function successfully added the amount and the current value of  the account’s balance is :”+ balance + “$”);

}

// this function accepts an input integer amount value to deposit into the shared account

public static void Deposit(int amount){

try {

System.out.println(“The deposit function is trying to add “+ amount +”$ to the shared balance”+ balance + “$”);

//IMPLEMENT HERE the deposit functionality,

// Deposit the input amount to the balance only if the current balance is less than 2000$

//  Deposit doesn’t wait until this condition is true (If the condition is  false, skip adding the amount), thus use if statements rather than  waiting while loops

// Call the displayStatus() function after you deposit the amount and before release the lock

// Implement the deposit functionality, as detailed above, in the area below

//——————————————–end of Deposit function

} catch (Exception e) {

System.out.println(“Problem with the deposite function “+e.toString());

}

}

// this function accepts an input integer amount value to withdraw from the shared account

public static void Withdraw(int amount){

try {

System.out.println(“The withdraw is trying to remove “+ amount +”$ from the shared balance”+ balance + “$”);

//IMPLEMENT HERE the withdraw functionality,

// withdraw the input amount from the balance only if the current balance is greater than or equal to input amount

//  Withdraw doesn’t wait until this condition is true (if the condition is  false, skip withdrawing the amount), thus use if statements rather than  waiting while loops

// Call the displayStatus() function after you remove the amount and before release the lock

// Implement the withdraw functionality, as detailed above, in the area below

//——————————————–end of Withdraw function

} catch (Exception e) {

System.out.println(“Problem with the withdraw function “+e.toString());

}

}

// this is the main function

// DONOT CHANGE THIS SECTION

public static void main(String[] args) {

//create thread 1 to run function 1

Thread thread1 = new Thread(new Runnable() {

@Override

public void run() {

while(true) {

try {

Deposit(200 + (int)(Math.random() * 1000)); //random value between 200 and 1000$

Thread.sleep(200 + (int)(Math.random() * 500)); //random delay between 200 and 500

} catch (Exception e) {

System.out.println(“Problem with thread 1 “+e.toString());

}

}

}

});

//create thread 2 to run function 2

Thread thread2 = new Thread(new Runnable() {

@Override

public void run() {

while(true) {

try {

Withdraw(200 + (int)(Math.random() * 1000)); //random value between 200 and 1000$

Thread.sleep(200 + (int)(Math.random() * 500)); //random delay between 200 and 500

} catch (Exception e) {

System.out.println(“Problem with thread 2 “+e.toString());

}

}

}

});

//ask the threads to start running

thread1.setName(“deposit”);

thread1.start();

thread2.setName(“withdraw”);

thread2.start();

}

}

Leave a Reply

Your email address will not be published. Required fields are marked *