From f263392866ab36fc6d9d77852e41b710858244a0 Mon Sep 17 00:00:00 2001 From: Aadit Agrawal Date: Mon, 14 Oct 2024 09:30:15 +0530 Subject: [PATCH] Upload files to "OOP/Java/Lab/Week11" --- OOP/Java/Lab/Week11/Practice_question.java | 126 ++++++++++++++++ OOP/Java/Lab/Week11/matrix_threaded.java | 161 +++++++++++++++++++++ OOP/Java/Lab/Week11/syncMethod.java | 43 ++++++ OOP/Java/Lab/Week11/syncStatements.java | 44 ++++++ OOP/Java/Lab/Week11/threadmaking.java | 53 +++++++ 5 files changed, 427 insertions(+) create mode 100644 OOP/Java/Lab/Week11/Practice_question.java create mode 100644 OOP/Java/Lab/Week11/matrix_threaded.java create mode 100644 OOP/Java/Lab/Week11/syncMethod.java create mode 100644 OOP/Java/Lab/Week11/syncStatements.java create mode 100644 OOP/Java/Lab/Week11/threadmaking.java diff --git a/OOP/Java/Lab/Week11/Practice_question.java b/OOP/Java/Lab/Week11/Practice_question.java new file mode 100644 index 0000000..4bca7d4 --- /dev/null +++ b/OOP/Java/Lab/Week11/Practice_question.java @@ -0,0 +1,126 @@ +// Online Java Compiler +/*interface product +{ + void buy(int num); +} +class genproduct implements product +{ + int quan; + genproduct(int n) + { + quan=n; + } + public synchronized void buy(int num) + { + if(quan extends Thread +{ + T obj; + int num; + inventory(T obj,int num) + { + this.obj=obj; + this.num=num; + } + public void run() + { + obj.buy(num); + } +} +class Mainclass +{ + public static void main(String[] args) { + genproduct buyer1 =new genproduct(15); + inventory t1=new inventory(buyer1,2); + inventory t2=new inventory(buyer1,5); + // obj.start(); + t1.start(); + t2.start(); + + + } +}*/ +class BankAccount { + private int balance; + private int accountNumber; + + public BankAccount(int accountNumber, int initialBalance) { + this.accountNumber = accountNumber; + this.balance = initialBalance; + } + + public synchronized void deposit(int amount) { + balance += amount; + System.out.println("Deposited: " + amount); + System.out.println("Current Balance after Deposit: " + balance); + } + + public synchronized void withdraw(int amount) { + if (balance >= amount) { + balance -= amount; + System.out.println("Withdrawn: " + amount); + System.out.println("Current Balance after Withdrawal: " + balance); + } else { + System.out.println("Insufficient funds for withdrawal."); + } + } +} + +class TransactionThread extends Thread { + private BankAccount account; + private boolean isDeposit; + private int amount; + + public TransactionThread(BankAccount account, boolean isDeposit, int amount) { + this.account = account; + this.isDeposit = isDeposit; + this.amount = amount; + } + + public void run() { + if (isDeposit) { + account.deposit(amount); + } else { + account.withdraw(amount); + } + } +} + +class Practice_question{ + public static void main(String[] args) { + BankAccount account = new BankAccount(12345, 1000); + + // Create multiple threads for deposits and withdrawals + TransactionThread depositThread1 = new TransactionThread(account, true, 500); + TransactionThread withdrawThread1 = new TransactionThread(account, false, 200); + TransactionThread depositThread2 = new TransactionThread(account, true, 100); + TransactionThread withdrawThread2 = new TransactionThread(account, false, 300); + + // Start the threads + depositThread1.start(); + withdrawThread1.start(); + depositThread2.start(); + withdrawThread2.start(); + + // Wait for all threads to finish + try { + depositThread1.join(); + withdrawThread1.join(); + depositThread2.join(); + withdrawThread2.join(); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } +} diff --git a/OOP/Java/Lab/Week11/matrix_threaded.java b/OOP/Java/Lab/Week11/matrix_threaded.java new file mode 100644 index 0000000..990bf26 --- /dev/null +++ b/OOP/Java/Lab/Week11/matrix_threaded.java @@ -0,0 +1,161 @@ +import java.util.Scanner; + +class Matrix { + static int[][] matrix; + + Matrix(int rows, int columns) { + matrix = new int[rows][columns]; + Scanner sc = new Scanner(System.in); + System.out.println("Enter the values"); + for (int i = 0; i < rows; i++) { + for (int j = 0; j < columns; j++) { + matrix[i][j] = sc.nextInt(); + } + } + } +} + +class DisplayMatrixThread extends Thread { + static int[][] matrix; + + DisplayMatrixThread(Matrix matrixObj) { + matrix = Matrix.matrix; + } + + public void run() { + for (int[] row : matrix) { + for (int value : row) { + System.out.print(value + "\t"); + } + System.out.println(); + } + } +} + +class TransposeMatrixThread extends Thread { + int[][] matrix; + + TransposeMatrixThread(Matrix matrixObj) { + matrix = matrixObj.matrix; + } + + public void run() { + int rows = matrix.length; + int columns = matrix[0].length; + + for (int j = 0; j < columns; j++) { + for (int i = 0; i < rows; i++) { + System.out.print(matrix[i][j] + "\t"); + } + System.out.println(); + } + } +} + +class MaxValueThread extends Thread { + static int[][] matrix; + + MaxValueThread(Matrix matrixObj) { + matrix = Matrix.matrix; + } + + public void run() { + int max = matrix[0][0]; + + for (int[] row : matrix) { + for (int value : row) { + if (value > max) { + max = value; + } + } + } + + System.out.println("Maximum value in the matrix: " + max); + } +} + +class PrincipalDiagonalThread extends Thread { + static int[][] matrix; + + PrincipalDiagonalThread(Matrix matrixObj) { + matrix = Matrix.matrix; + } + + public void run() { + int rows = matrix.length; + int columns = matrix[0].length; + + System.out.print("Principal Diagonal Elements: "); + for (int i = 0; i < Math.min(rows, columns); i++) { + System.out.print(matrix[i][i] + " "); + } + System.out.println(); + } +} + +class NonDiagonalThread extends Thread { + static int[][] matrix; + + NonDiagonalThread(Matrix matrixObj) { + matrix = Matrix.matrix; + } + + public void run() { + int rows = matrix.length; + int columns = matrix[0].length; + + System.out.print("Non-Diagonal Elements: "); + for (int i = 0; i < rows; i++) { + for (int j = 0; j < columns; j++) { + if (i != j) { + System.out.print(matrix[i][j] + " "); + } + } + } + System.out.println(); + } +} + +class ThreadMatrix { + public static void main(String[] args) { + Scanner sc = new Scanner(System.in); + System.out.println("Enter the no. of rows and columns"); + int rows = sc.nextInt(); + int columns = sc.nextInt(); + Matrix matrixObj = new Matrix(rows, columns); + + DisplayMatrixThread t1 = new DisplayMatrixThread(matrixObj); + TransposeMatrixThread t2 = new TransposeMatrixThread(matrixObj); + MaxValueThread t3 = new MaxValueThread(matrixObj); + PrincipalDiagonalThread t4 = new PrincipalDiagonalThread(matrixObj); + NonDiagonalThread t5 = new NonDiagonalThread(matrixObj); + + try { + t1.start(); + System.out.println("\nThread t1 is alive: " + t1.isAlive()); + t1.join(); + t2.start(); + System.out.println("\nThread t2 is alive: " + t2.isAlive()); + t2.join(); + t3.start(); + System.out.println("\nThread t3 is alive: " + t3.isAlive()); + t3.join(); + t4.start(); + System.out.println("\nThread t4 is alive: " + t4.isAlive()); + t4.join(); + t5.start(); + System.out.println("\nThread t5 is alive: " + t5.isAlive()); + t5.join(); + } catch (InterruptedException e) { + e.printStackTrace(); + } + + System.out.println("\nThread t1 is alive: " + t1.isAlive()); + System.out.println("Thread t2 is alive: " + t2.isAlive()); + System.out.println("Thread t3 is alive: " + t3.isAlive()); + System.out.println("Thread t4 is alive: " + t4.isAlive()); + System.out.println("Thread t5 is alive: " + t5.isAlive()); + + System.out.println("\nMain thread exits."); + } +} \ No newline at end of file diff --git a/OOP/Java/Lab/Week11/syncMethod.java b/OOP/Java/Lab/Week11/syncMethod.java new file mode 100644 index 0000000..59a3419 --- /dev/null +++ b/OOP/Java/Lab/Week11/syncMethod.java @@ -0,0 +1,43 @@ + +class Incrementer{ + int count; + Incrementer(int cnt) + { + count=cnt; + } + synchronized void increment() + { + count++; + } +} + +class IncrementThread extends Thread{ + Incrementer ref; + IncrementThread(Incrementer obj) + { + ref=obj; + } + public void run() + { + for(int i=0;i<10000;i++) + { + ref.increment(); + } + } +} +class syncMethod{ + public static void main(String[] args) { + Incrementer inc=new Incrementer(0); + IncrementThread t1=new IncrementThread(inc); + IncrementThread t2=new IncrementThread(inc); + t1.start(); + t2.start(); + try { + t1.join(); + t2.join(); + } catch (InterruptedException e) { + System.out.println(e.toString()); + } + System.out.println(inc.count); + } +} diff --git a/OOP/Java/Lab/Week11/syncStatements.java b/OOP/Java/Lab/Week11/syncStatements.java new file mode 100644 index 0000000..e557deb --- /dev/null +++ b/OOP/Java/Lab/Week11/syncStatements.java @@ -0,0 +1,44 @@ +class IncrementThread extends Thread{ + Incrementer ref; + IncrementThread(Incrementer obj) + { + ref=obj; + } + public void run() + { + for(int i=0;i<10000;i++) + { + ref.increment(); + } + } +} +class Incrementer{ + int count; + Incrementer(int cnt) + { + count=cnt; + } + void increment() + { + synchronized(this) + { + count++; + } + } +} +class syncMethod{ + public static void main(String[] args) { + Incrementer inc=new Incrementer(0); + IncrementThread t1=new IncrementThread(inc); + IncrementThread t2=new IncrementThread(inc); + t1.start(); + t2.start(); + try { + t1.join(); + t2.join(); + } catch (InterruptedException e) { + System.out.println(e.toString()); + } + System.out.println(inc.count); + } +} diff --git a/OOP/Java/Lab/Week11/threadmaking.java b/OOP/Java/Lab/Week11/threadmaking.java new file mode 100644 index 0000000..ac7eae6 --- /dev/null +++ b/OOP/Java/Lab/Week11/threadmaking.java @@ -0,0 +1,53 @@ +import java.util.Scanner; + +class MyRunnable implements Runnable { + public void run() { + System.out.println("Thread created by runnable "); + try { + Thread.sleep(500); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } +} + +class MyThread extends Thread { + public void run() { + System.out.println("Thread created by Thread class"); + try { + Thread.sleep(500); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } +} + +class Threadmaking { + public static void main(String[] args) { + Scanner sc = new Scanner(System.in); + + while (true) { + System.out.println("\nChoose an option:"); + System.out.println("1. Create Thread using Runnable Interface"); + System.out.println("2. Create Thread by Inheriting Thread Class"); + System.out.println("3. Exit"); + + int choice = sc.nextInt(); + + switch (choice) { + case 1: + Thread runnableThread = new Thread(new MyRunnable());//creating a runnable object which is directly passed to Thread + runnableThread.start(); + break; + case 2: + MyThread myThread = new MyThread(); + myThread.start(); + break; + case 3: + System.exit(0); + default: + System.out.println("Invalid choice. Please enter a valid option."); + } + } + } +} \ No newline at end of file