Java ProgrammingPlease help me with this Java Progamming projectNOT GRADED. Practice homeworkPlease comment the code well and organize the classes so I can understand. Thank you!If solution if the one that is desirable, I will upvote! I really appreciate this, Bartleby!Waiting Times should not be negative. You sent back a solution but the waiting time was negative and that was incorrect. Please take your time and help me with this. **Task Set**Consider the following task set:| Task Name | Priority (when applicable) | CPU burst (ms) ||-----------|----------------------------|----------------|| T1 | 2 | 20 || T2 | 4 | 25 || T3 | 3 | 25 || T4 | 3 | 15 || T5 | 1 | 10 |**Task Set Details:**- Priorities range from 1 to 4, where a lower numeric value indicates a higher relative priority.- For round-robin scheduling, the length of a time quantum is 10 milliseconds.**Scheduling Algorithms:**Implement the following four scheduling algorithms in four different threads using the Java programming language. The main thread will print on the console the generated schedule using a modified Gantt chart, average waiting time, and average turnaround time for each algorithm.1. **First-come, first-served (FCFS):** - Assumes all the tasks arrive at the same time.2. **Shortest-job-first (SJF):** - Assumes all the tasks arrive at the same time. - Breaks ties randomly.3. **Preemptive priority scheduling (PS):** - Uses the given priorities and a random arrival time (in ms) in the interval [0, 100] for each task. - Random arrival times must be generated using a Java random number generator. - Print arrival times before printing the schedule.4. **Round-robin (RR) scheduling:** - Each task runs for a time quantum (or for the remainder of its CPU burst). [Scheduling Algorithm Name:][Arrival Times (only for PS algorithm)][A textual presentation of the Gantt chart of the generated schedule (see example)][Avg. waiting time: …][Avg. turnaround time: …]Example:**FCFS:**- T1 [0 – 20], T2 [24 – 45], T3 [45 – 70], …- Avg. waiting time: 12.3- Avg. turnaround time: 12.3**SJF:**- …..- …..- …..**PS:**- Arrival Times: T1 = 10, T2 = 70, T3 = 30, …- T1 [10 – 30], T3 [….- …..- …..**RR:**- …..- …..- …..**Note:** T1 [0 – 20] means that the task T1 is run from 0 to 20 ms. Please don’t show your outputs in any other formats (e.g., by adding extra commas, symbols, etc.).

Import necessary Java libraries (ArrayList, Collections, List, and Random).Define a Task class to…

Answered: Java Programming Please help me with…

Database System Concepts

7th Edition

ISBN:9780078022159

Author:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Publisher:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan

Chapter1: Introduction

Section: Chapter Questions

Problem 1PE

See similar textbooks

Related questions

Question

Java Programming

Please help me with this Java Progamming project

NOT GRADED. Practice homework

Please comment the code well and organize the classes so I can understand. Thank you!

If solution if the one that is desirable, I will upvote! I really appreciate this, Bartleby!

Waiting Times should not be negative. You sent back a solution but the waiting time was negative and that was incorrect. Please take your time and help me with this.

**Task Set**

Consider the following task set:

| Task Name | Priority (when applicable) | CPU burst (ms) |
|-----------|----------------------------|----------------|
| T1 | 2 | 20 |
| T2 | 4 | 25 |
| T3 | 3 | 25 |
| T4 | 3 | 15 |
| T5 | 1 | 10 |

**Task Set Details:**
- Priorities range from 1 to 4, where a lower numeric value indicates a higher relative priority.
- For round-robin scheduling, the length of a time quantum is 10 milliseconds.

**Scheduling Algorithms:**
Implement the following four scheduling algorithms in four different threads using the Java programming language. The main thread will print on the console the generated schedule using a modified Gantt chart, average waiting time, and average turnaround time for each algorithm.

1. **First-come, first-served (FCFS):**
- Assumes all the tasks arrive at the same time.

2. **Shortest-job-first (SJF):**
- Assumes all the tasks arrive at the same time.
- Breaks ties randomly.

3. **Preemptive priority scheduling (PS):**
- Uses the given priorities and a random arrival time (in ms) in the interval [0, 100] for each task.
- Random arrival times must be generated using a Java random number generator.
- Print arrival times before printing the schedule.

4. **Round-robin (RR) scheduling:**
- Each task runs for a time quantum (or for the remainder of its CPU burst).

[Scheduling Algorithm Name:]
[Arrival Times (only for PS algorithm)]
[A textual presentation of the Gantt chart of the generated schedule (see example)]
[Avg. waiting time: …]

[Avg. turnaround time: …]

Example:

**FCFS:**
- T1 [0 – 20], T2 [24 – 45], T3 [45 – 70], …
- Avg. waiting time: 12.3
- Avg. turnaround time: 12.3

**SJF:**
- …..
- …..
- …..

**PS:**
- Arrival Times: T1 = 10, T2 = 70, T3 = 30, …
- T1 [10 – 30], T3 [….
- …..
- …..

**RR:**
- …..
- …..
- …..

**Note:** T1 [0 – 20] means that the task T1 is run from 0 to 20 ms. Please don’t show your outputs in any other formats (e.g., by adding extra commas, symbols, etc.).

Expert Solution

Step 1: Algorithm for Task Scheduling with Multiple Algorithms

Import necessary Java libraries (ArrayList, Collections, List, and Random).
Define a Task class to represent tasks with attributes such as name, priority, burst time, and arrival time. Initialize these attributes through a constructor.
Create a public class named SchedulingAlgorithms.
In the main method:

Initialize the task set using the initializeTaskSet method.
Create and start four threads to execute different scheduling algorithms: FCFS, SJF, Priority Scheduling, and Round-Robin.

Implement the initializeTaskSet method:

Initialize the taskSet as an ArrayList.
Create Task objects and add them to the task set.
Assign random arrival times in the range [0, 100].
Sort tasks based on arrival time in ascending order.

Implement the executeFCFS method:
- Calculate the wait time, turnaround time, and update the current time.
- Print the schedule for each task.

Initialize variables to keep track of current time, total wait time, and total turnaround time.
For each task in the task set:
Calculate and print the average waiting and turnaround times.

Implement the executeSJF method:

Sort tasks based on burst time in ascending order.
Call the executeFCFS method to execute Shortest Job First (SJF) scheduling.

Implement the executePriority method:
- Calculate the wait time, turnaround time, and update the current time.
- Print the schedule for each task.

Initialize variables to keep track of current time, total wait time, and total turnaround time.
For each task in the task set:
Calculate and print the average waiting and turnaround times.

Implement the executeRoundRobin method:
- For each task in the list of remaining tasks:

Initialize variables to keep track of current time, total wait time, total turnaround time, and define the time quantum.
Create a list of remaining tasks as a copy of the task set.
While there are remaining tasks:
Calculate and print the average waiting and turnaround times.

Implement the printAverages method:

Calculate the average waiting and turnaround times.
Print the calculated average waiting and turnaround times.

End of the algorithm.

This algorithm describes the high-level steps for scheduling tasks using First-Come-First-Serve (FCFS), Shortest Job First (SJF), Priority Scheduling, and Round-Robin scheduling algorithms as implemented in the provided Java code.

Step by step

Solved in 6 steps with 7 images

SEE SOLUTION Check out a sample Q&A here

Knowledge Booster

Learn more about

Need a deep-dive on the concept behind this application? Look no further. Learn more about this topic, computer-science and related others by exploring similar questions and additional content below.

Similar questions