Create a PostalWorkerThread class that extends Thread, which will se.pdf

Create a PostalWorkerThread class that extends Thread, which will serve the customers in line.
The PostalWorkerThread class will need to acquire the postalWorkerMutex semaphore to enter
the critical section where it can interact with the customer threads. Once a postal worker thread
finishes serving a customer, it should release the postalWorkerMutex semaphore. You also need
to ensure that only one postal worker can use the scales at a time. Currently, my code creates a
semaphore for scalesMutex, but it is not being used in the code. You should also add print
statements to my code to match the output format mentioned in the project description.
My code:
import java.util.LinkedList;
import java.util.Queue;
import java.util.Random;
import java.util.concurrent.Semaphore;
public class PostOfficeSimulation {
// Constants
private static final int MAX_CUSTOMERS = 50;
private static final int MAX_CUSTOMERS_INSIDE = 10;
private static final int MAX_POSTAL_WORKERS = 3;
// Semaphores
private static Semaphore customerMutex = new Semaphore(1);
private static Semaphore postalWorkerMutex = new Semaphore(1);
private static Semaphore scalesMutex = new Semaphore(1);
private static Semaphore customersInside = new Semaphore(MAX_CUSTOMERS_INSIDE);
private static Semaphore postalWorkersAvailable = new
Semaphore(MAX_POSTAL_WORKERS);
// Task Table
private static final int BUY_STAMPS_TIME = 60;
private static final int MAIL_LETTER_TIME = 90;
private static final int MAIL_PACKAGE_TIME = 120;
// Random number generator
private static Random random = new Random();
// Customer thread
private static class CustomerThread extends Thread {
private int id;

private int task;
private Semaphore semaphore;
public CustomerThread(int id) {
this.id = id;
this.task = random.nextInt(3);
this.semaphore = new Semaphore(0);
}
public void run() {
try {
System.out.printf("Customer %d createdn", id);
customersInside.acquire();
System.out.printf("Customer %d enters post officen", id);
Thread.sleep(1000 * getTaskTime() / 60);
System.out.printf("Customer %d asks postal worker to %sn", id, getTaskName());
postalWorkerMutex.acquire();
postalWorkersAvailable.acquire();
System.out.printf("Postal worker %d serving customer %dn", getPostalWorkerId(),
id);
scalesMutex.acquire();
Thread.sleep(1000 * getTaskTime() / 60);
scalesMutex.release();
System.out.printf("Postal worker %d finished serving customer %dn",
getPostalWorkerId(), id);
postalWorkersAvailable.release();
postalWorkerMutex.release();
Thread.sleep(1000);
System.out.printf("Customer %d finished %sn", id, getTaskName());
System.out.printf("Customer %d leaves post officen", id);
customersInside.release();
semaphore.release();
System.out.printf("Joined customer %dn", id);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private int getTaskTime() {

switch (task) {
case 0:
return BUY_STAMPS_TIME;
case 1:
return MAIL_LETTER_TIME;
case 2:
return MAIL_PACKAGE_TIME;
default:
return 0;
}
}
private String getTaskName() {
switch (task) {
case 0:
return "buy stamps";
case 1:
return "mail a letter";
case 2:
return "mail a package";
default:
return "";
}
}
private int getPostalWorkerId() {
return id % MAX_POSTAL_WORKERS;
}
public void releaseSemaphore() {
semaphore.release();
}
}
// Postal worker thread
private static class PostalWorkerThread extends Thread {
private int id;
public PostalWorkerThread(int id) {
// Postal worker thread

private static class PostalWorkerThread extends Thread {
private int id;
public PostalWorkerThread(int id) {
this.id = id;
}
@Override
public void run() {
System.out.printf("Postal worker %d createdn", id);
while (true) {
try {
// Wait for a customer to arrive
customersInside.acquire();
customerMutex.acquire();
// Serve the customer
System.out.printf("Postal worker %d serving customer %dn", id,
Main.customerQueue.peek().id);
switch (Main.customerQueue.peek().task) {
case 0:
Thread.sleep(BUY_STAMPS_TIME * 1000);
System.out.printf("Customer %d finished buying stampsn",
break;
case 1:
Thread.sleep(MAIL_LETTER_TIME * 1000);
System.out.printf("Customer %d finished mailing a lettern",
break;
case 2:
scalesMutex.acquire();
System.out.println("Scales in use by postal worker " + id);
Thread.sleep(MAIL_PACKAGE_TIME * 1000);
System.out.printf("Customer %d finished mailing a packagen",

scalesMutex.release();
break;
}
Main.customerQueue.poll().releaseSemaphore();
// Release resources
customerMutex.release();
customersInside.release();
}
}
}
}
// Main class
public static class Main {
public static Semaphore customerSemaphore = new Semaphore(0);
public static Queue customerQueue = new LinkedList<>();
public static void main(String[] args) {
System.out.println("Simulating Post Office with 50 customers and 3 postal workers");
// Start postal worker threads
for (int i = 0; i < MAX_POSTAL_WORKERS; i++) {
new PostalWorkerThread(i).start();
}
// Start customer threads
for (int i = 0; i < MAX_CUSTOMERS; i++) {
CustomerThread customerThread = new CustomerThread(i);
customerThread.start();
try {
Thread.sleep(random.nextInt(500) + 500); // Sleep for 0.5-1.0 seconds

}
}
// Join all customer threads
try {
customerSemaphore.acquire();
}
}
// Print joined messages
System.out.printf("Joined customer %dn", i);
}
}
}
}

Create a PostalWorkerThread class that extends Thread, which will se.pdf

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Ähnlich wie Create a PostalWorkerThread class that extends Thread, which will se.pdf

Ähnlich wie Create a PostalWorkerThread class that extends Thread, which will se.pdf (20)

Mehr von ameerandsons

Mehr von ameerandsons (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Create a PostalWorkerThread class that extends Thread, which will se.pdf