diff --git a/Answer b/Answer new file mode 100644 index 0000000..8b35a8a --- /dev/null +++ b/Answer @@ -0,0 +1,28 @@ +## First Question: + 1.An interrupt is an indication to a thread that it should stop what it is doing and do something else. It's up to the programmer to decide exactly how a thread responds to an interrupt, but it is very common for the thread to terminate. + 2.In this code the target thread has been sleeping (by calling sleep()) , it will be interrupted , meaning that it stops waiting for what was waiting for and receives an InterruptedException instead. + +## Output: +The outputs of this code are : " + Thread was interrupted! + Thread will be finished here!! + + +## Second Question: + 1.In this code the run() method directly on a Runnable object in Java will not start a new thread. Instead, the run() method will execute in the current thread, just like any other method call. This means that the code within the run() method will run sequentially in the calling thread, and no multithreading behavior will occur. +The run() method is called directly, so the message will be printed from the main thread. + +## Output: +The output of this code is : + Runnig in : main + + +## Third Question: + The join method allows one thread to wait for the completion of another. If t is a Thread object whose thread is currently executing, t. join(); causes the current thread to pause execution until t 's thread terminates. + +## Output: +The outputs of this code are: + Running in: Thread-0 + Back to: main + + diff --git a/README.md b/README.md deleted file mode 100644 index d69deb2..0000000 --- a/README.md +++ /dev/null @@ -1,150 +0,0 @@ -# Fifth-Assignment-Multithread-Basics - -## Table of contents - -- [Introduction 👋](#introduction-) -- [Objectives 🎯](#objectives-) -- [Tasks 📋](#tasks-) - - [Theoretical Questions 📝](#theoretical-questions-) - - [Practical Questions 💻](#practical-questions-) -- [Evaluation ⚖️](#evaluation-) -- [Submission ⌛](#submission-) -- [Resources 📚](#resources-) - -## Introduction 👋 - -Welcome to your Fifth Advanced Programming (AP) journey, where you'll delve into the fascinating world of multithreading in Java. This project is divided into two main sections: - -1. **Theoretical Questions**: This section is designed to deepen your understanding of key multithreading concepts in Java. You'll have to analyze three code blocks and answer questions about them. - -2. **Practical Questions**: In this section, you'll get hands-on experience with multithreading in Java. Test cases are provided for each problem, but your code will still be manually checked to ensure you've implemented - - -## Objectives 🎯 - -By completing this assignment, you will: - -- Deepen your understanding of **multithreading** in Java and apply the concepts effectively. -- Gain familiarity with key multithreading concepts such as the `Runnable` interface, the `Thread` class, the `interrupt()` method, and the `run()` method. - -Note that while this assignment covers many important aspects of multithreading, there are some advanced topics such as race condition and synchronization that won't be covered in this assignment and will be introduced in the following week. However, a solid understanding of the concepts covered in this assignment is crucial for grasping those advanced topics. - -## Tasks 📋 - -### Theoretical Questions 📝 - -**Note: Please answer these questions in a Markdown file and place it in the root directory of your fork. Include code or screenshots where you see fit.** - -1. **What will be printed after interrupting the thread?** - -```java -public static class SleepThread extends Thread { - public void run() { - try { - Thread.sleep(10000); - } catch (InterruptedException e) { - System.out.println("Thread was interrupted!"); - } finally { - System.out.println("Thread will be finished here!!!"); - } - } - } - - public static void main(String[] args) { - SleepThread thread = new SleepThread(); - thread.start(); - thread.interrupt(); - } -``` -2. In Java, what would be the outcome if the `run()` method of a `Runnable` object is invoked directly, without initiating it inside a `Thread` object? -```java -public class DirectRunnable implements Runnable { - public void run() { - System.out.println("Running in: " + Thread.currentThread().getName()); - } -} - -public class Main { - public static void main(String[] args) { - DirectRunnable runnable = new DirectRunnable(); - runnable.run(); - } -} -``` -3. Elaborate on the sequence of events that occur when the `join()` method of a thread (let's call it `Thread_0`) is invoked within the `Main()` method of a Java program. -```java -public class JoinThread extends Thread { - public void run() { - System.out.println("Running in: " + Thread.currentThread().getName()); - } -} - -public class Main { - public static void main(String[] args) { - JoinThread thread = new JoinThread(); - thread.start(); - try { - thread.join(); - } catch (InterruptedException e) { - e.printStackTrace(); - } - System.out.println("Back to: " + Thread.currentThread().getName()); - } -} -``` - -### Practical Questions 💻 - -**Task Scheduler**: - -- In this problem, you are given an **ArrayList** of tasks, each with two fields: **taskName** and **processingTime**. The goal is to sort these tasks based on their priority, where tasks with longer processing times have higher priority. After sorting, we’ll create separate threads for each task and execute them. Importantly, we’ll wait for each thread to finish its work to ensure the desired execution order. Finally, we’ll return the order of task execution. - -**Parallelizing Matrix Multiplication**: - -- In this problem, you are asked to write a program that can parallelize matrix multiplication using multithreading. - -- In the **ParallelizeMatMul** method, you will be given two matrices, **A** and **B**. Matrix **A** has dimensions **p** × **q**, and matrix **B** has dimensions **q** × **r** (where both **p** and **r** are even numbers). Your task is to compute the product of matrices **A** and **B** to obtain a resulting matrix, **C**. To achieve faster execution, we’ll utilize multithreading. - -- **Hint**: - - Divide the final matrix **C** into four equal quarters, as shown in the figure below. Assign each quarter to a separate thread for calculations. - - ![](./Images/OIG3.jpeg) - - - Procedure: - 1. Divide the quarters among four threads in the **ParallelizeMatMul** method. - 2. Specify how each thread should calculate the elements in its assigned quarter within its **run()** method. - 3. Store the calculated elements from each thread in temporary matrices. - 4. Combine the temporary matrices to construct the final matrix **C**. - - -## Evaluation ⚖️ - -Your work on this assignment will be evaluated based on: - -- **Understanding of Multithreading Concepts**: Your ability to accurately answer the theoretical questions, demonstrating a deep understanding of multithreading in Java. Remember that the answers to the theoretical questions should be provided separately in a markdown file. - -- **Test Cases**: Your code should pass all the tests provided in the test directory. Make sure to enable GitHub Actions to run the tests on GitHub. - -- **Code Quality**: Your code should be well-structured, readable, and efficient. Proper use of Java conventions, including variable naming, class structure, and comments, will also be considered. - -## Submission ⌛ - -1. Add your mentor as a contributor to the project. -2. Create a `develop` branch for implementing features. -3. Use Git for regular code commits. -4. Push your code and the answers file to the remote repository. -5. Submit a pull request to merge the `develop` branch with `main`. - -The deadline for submitting your code is **Wednesday, May 8** (19th of Ordibehesht) - -## Resources 📚 - -For assistance with this assignment, you may refer to the following resources: - -🔗 [Multithreading in Java on Java Point](https://www.javatpoint.com/multithreading-in-java) - -🔗 [Multithreading in Java on Tutorials Point](https://www.tutorialspoint.com/java/java_multithreading.htm) - -🔗 [Multithreading in Java on Geeks for Geeks](https://www.geeksforgeeks.org/multithreading-in-java/) - -Also, you can find a wealth of knowledge from various YouTube courses. They can be a great source of learning. Alongside, joining discussions on forums and reading helpful documents can also be beneficial. diff --git a/src/main/java/sbu/cs/MatrixMultiplication.java b/src/main/java/sbu/cs/MatrixMultiplication.java index 2f00c59..efbf78d 100644 --- a/src/main/java/sbu/cs/MatrixMultiplication.java +++ b/src/main/java/sbu/cs/MatrixMultiplication.java @@ -1,15 +1,22 @@ package sbu.cs; +import java.sql.SQLOutput; +import java.util.ArrayList; import java.util.List; public class MatrixMultiplication { // You are allowed to change all code in the BlockMultiplier class - public static class BlockMultiplier implements Runnable - { - List> tempMatrixProduct; - public BlockMultiplier() { + public static class BlockMultiplier implements Runnable { + List> tempMatrixProduct = new ArrayList<>(); + int task; + List> matrix_A, matrix_B; + + public BlockMultiplier(List> matrix_A, List> matrix_B, int task) { // TODO + this.task = task; + this.matrix_A = matrix_A; + this.matrix_B = matrix_B; } @Override @@ -18,6 +25,70 @@ public void run() { TODO Perform the calculation and store the final values in tempMatrixProduct */ + int m ,n,r; + m = matrix_A.size(); + r = matrix_B.get(0).size(); + n = matrix_B.size(); + if (task == 1 ){ + for (int i =0 ; i satr = new ArrayList<>(); + for (int j =0 ; j satr = new ArrayList<>(); + for (int j =r/2 ; j satr = new ArrayList<>(); + for (int j =0 ; j satr = new ArrayList<>(); + for (int j =r/2 ; j> getTempMatrixProduct() { + return tempMatrixProduct; } } @@ -34,10 +105,61 @@ public static List> ParallelizeMatMul(List> matrix_A Each thread should calculate one block of the final matrix product. Each block should be a quarter of the final matrix. Combine the 4 resulting blocks to create the final matrix product and return it. */ - return null; - } + List> ParallelizeMatMul = new ArrayList<>(); + + List> mat1 = new ArrayList<>(); + List> mat2 = new ArrayList<>(); + List> mat3 = new ArrayList<>(); + List> mat4 = new ArrayList<>(); + + BlockMultiplier BM1 = new BlockMultiplier(matrix_A, matrix_B, 1); + BlockMultiplier BM2 = new BlockMultiplier( matrix_A, matrix_B,2); + BlockMultiplier BM3 = new BlockMultiplier( matrix_A, matrix_B,3); + BlockMultiplier BM4 = new BlockMultiplier( matrix_A, matrix_B , 4); + + Thread thread1 = new Thread(BM1); + Thread thread2 = new Thread(BM2); + Thread thread3 = new Thread(BM3); + Thread thread4 = new Thread(BM4); + + thread1.start(); + thread2.start(); + thread3.start(); + thread4.start(); + + try { + thread1.join(); + mat1 = BM1.getTempMatrixProduct(); + thread2.join(); + mat2 = BM2.getTempMatrixProduct(); + thread3.join(); + mat3 = BM3.getTempMatrixProduct(); + thread4.join(); + mat4 = BM4.getTempMatrixProduct(); + }catch (InterruptedException e) { + System.out.println("thread Interrupted."); + } + for (int i = 0; i < mat1.size(); i++) { + List satr = new ArrayList<>(); + for (int j = 0; j < mat1.get(0).size(); j++) + satr.add(mat1.get(i).get(j)); + for (int j = 0; j < mat2.get(0).size(); j++) + satr.add(mat2.get(i).get(j)); + ParallelizeMatMul.add(satr); + } + for (int i = 0; i < mat3.size(); i++) { + List satr = new ArrayList<>(); + for (int j = 0; j < mat3.get(0).size(); j++) + satr.add(mat3.get(i).get(j)); + for (int j = 0; j < mat4.get(0).size(); j++) + satr.add(mat4.get(i).get(j)); + ParallelizeMatMul.add(satr); + } + return ParallelizeMatMul; + } public static void main(String[] args) { // Test your code here + } } diff --git a/src/main/java/sbu/cs/TaskScheduler.java b/src/main/java/sbu/cs/TaskScheduler.java index 8725c2a..bcbc246 100644 --- a/src/main/java/sbu/cs/TaskScheduler.java +++ b/src/main/java/sbu/cs/TaskScheduler.java @@ -1,8 +1,12 @@ package sbu.cs; import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; import java.util.List; +import static java.lang.Thread.sleep; + public class TaskScheduler { public static class Task implements Runnable @@ -17,6 +21,11 @@ public Task(String taskName, int processingTime) { this.taskName = taskName; this.processingTime = processingTime; } + + public int getProcessingTime() { + return processingTime; + } + /* ------------------------- You don't need to modify this part of the code ------------------------- */ @@ -27,6 +36,12 @@ public void run() { TODO Simulate utilizing CPU by sleeping the thread for the specified processingTime */ + try { + Thread.sleep(processingTime); + } catch (InterruptedException e) { + System.out.println("mnm mnm shirmoz");; + } + } } @@ -41,11 +56,25 @@ public static ArrayList doTasks(ArrayList tasks) You have to wait for each task to get done and then start the next task. Don't forget to add each task's name to the finishedTasks after it's completely finished. */ + Collections.sort(tasks , Comparator.comparing(Task :: getProcessingTime)); + for (int i =tasks.size()-1 ; i>=0 ; i--){ + finishedTasks.add(tasks.get(i).taskName); + Thread thread = new Thread(tasks.get(i)); + thread.start(); + try { + thread.join(); + } catch (InterruptedException e) { + throw new RuntimeException(e); + } + } return finishedTasks; } public static void main(String[] args) { // Test your code here + ArrayList tasks = new ArrayList<>(); + System.out.println(doTasks(tasks)); + } }