Week 7 – Tutorial Assignment

CONCURRENT PROGRAMMING PARADIGM: THREAD CLASSES AND METHODS

RA2311026010866

1. import java.util.Random;

class RandomNumberGenerator extends Thread {

private final NumberProcessor processor;

public RandomNumberGenerator(NumberProcessor processor) {

this.processor = processor;

public void run() {

Random random = new Random();

while (true) {

int number = random.nextInt(100); // Generate random integer between 0 and 99

System.out.println("Generated Number: " + number);

processor.processNumber(number);

try {

Thread.sleep(1000); // Sleep for 1 second

} catch (InterruptedException e)

{ Thread.currentThread().interrupt();

}
 }

class EvenNumberProcessor extends Thread {

private final NumberProcessor processor;

public EvenNumberProcessor(NumberProcessor processor) {

this.processor = processor;

public void run() {

while (true) {

Integer number = processor.getEvenNumber();

if (number != null) {

int square = number * number; System.out.println("Square

of " + number + ": " + square);

class OddNumberProcessor extends Thread {

private final NumberProcessor processor;

public OddNumberProcessor(NumberProcessor processor) {

this.processor = processor;

}
 public void run() {

while (true) {

Integer number = processor.getOddNumber();

if (number != null) {

int cube = number * number * number;

System.out.println("Cube of " + number + ": " + cube);

class NumberProcessor {

private Integer evenNumber = null;

private Integer oddNumber = null;

public synchronized void processNumber(int number) {

if (number % 2 == 0) {

evenNumber = number;

notifyAll(); // Notify threads that a new even number is available

} else {

oddNumber = number;

notifyAll(); // Notify threads that a new odd number is available

}
 public synchronized Integer getEvenNumber() {

while (evenNumber == null) {

try {

wait(); // Wait for an even number to be available

} catch (InterruptedException e)

{ Thread.currentThread().interrupt();

Integer number = evenNumber;

evenNumber = null; // Reset the even number

return number;

public synchronized Integer getOddNumber() {

while (oddNumber == null) {

try {

wait(); // Wait for an odd number to be available

} catch (InterruptedException e)

{ Thread.currentThread().interrupt();

Integer number = oddNumber;

oddNumber = null; // Reset the odd number

return number;

}
public class Main {

public static void main(String[] args) {

NumberProcessor processor = new NumberProcessor();

RandomNumberGenerator generator = new RandomNumberGenerator(processor);

EvenNumberProcessor evenProcessor = new EvenNumberProcessor(processor);

OddNumberProcessor oddProcessor = new OddNumberProcessor(processor);

generator.start();

evenProcessor.start();

oddProcessor.start();

2. import java.util.LinkedList;
import java.util.Queue;

class Producer extends Thread { private

final Queue<Integer> queue; private

final int maxSize;

public Producer(Queue<Integer> queue, int maxSize) {

this.queue = queue;

this.maxSize = maxSize;

public void run()

{ int value = 0;

while (true) {

synchronized (queue) {

while (queue.size() == maxSize) {

try {

queue.wait(); // Wait until space is available

} catch (InterruptedException e)

{ Thread.currentThread().interrupt();

System.out.println("Produced: " + value);

queue.add(value++);

queue.notify(); // Notify the consumer that a new item is available

}
 }

class Consumer extends Thread {

private final Queue<Integer> queue;

public Consumer(Queue<Integer> queue) {

this.queue = queue;

public void run() {

while (true) {

synchronized (queue) {

while (queue.isEmpty()) {

try {

queue.wait(); // Wait until an item is available

} catch (InterruptedException e)

{ Thread.currentThread().interrupt();

int value = queue.poll();

System.out.println("Consumed: " + value);

queue.notify(); // Notify the producer that space is available

}
 }

public class Main {

public static void main(String[] args)

{ Queue<Integer> queue = new LinkedList<>();

int maxSize = 5;

Producer producer = new Producer(queue, maxSize);

Consumer consumer = new Consumer(queue);

producer.start();

consumer.start();

}
3. class MyThread extends Thread {

public void run() {

System.out.println("Original Thread Name: " + Thread.currentThread().getName());

try {

Thread.sleep(5000); // Sleep for 5 seconds

} catch (InterruptedException e)

{ Thread.currentThread().interrupt();

} Thread.currentThread().setName("ChangedThreadName");

System.out.println("Changed Thread Name: " + Thread.currentThread().getName());

}
public class Main {

public static void main(String[] args)

{ MyThread thread = new

MyThread(); thread.start();

4. class CountdownThread extends Thread {

public void run() {

for (int i = 5; i >= 1; i--)

{ System.out.println("Count: " + i);

try {

Thread.sleep(6000); // Sleep for 6 seconds

} catch (InterruptedException e)

{ Thread.currentThread().interrupt();

} Thread.currentThread().setName("CountdownCompleteThread");

System.out.println("Changed Thread Name: " + Thread.currentThread().getName());

public class Main {

 public static void main(String[] args) { CountdownThread

thread = new CountdownThread(); thread.start();

5. class UserThread extends Thread {

public void run() {

for (int i = 0; i < 5; i++)

{ System.out.println("User Thread: " + i);

try {

Thread.sleep(1000); // Sleep for 1 second

} catch (InterruptedException e)

{ Thread.currentThread().interrupt();

public class Main {

public static void main(String[] args)

{ UserThread userThread = new UserThread();

 userThread.start(); // Start the user thread

for (int i = 0; i < 5; i++)

{ System.out.println("Main Thread: " + i);

try {

Thread.sleep(1000); // Sleep for 1 second

} catch (InterruptedException e)

{ Thread.currentThread().interrupt();

6. class Printer {

private final Object lock = new Object();

private int currentJob = 1;

public void printJob(int jobNumber) {

synchronized (lock) {

while (jobNumber != currentJob) {

 try {

lock.wait(); // Wait for the correct job order

} catch (InterruptedException e)

{ Thread.currentThread().interrupt();

System.out.println("Printing Job: " + jobNumber);

currentJob++;

lock.notifyAll(); // Notify the next job

class JobThread extends Thread

{ private final Printer printer;

private final int jobNumber;

public JobThread(Printer printer, int jobNumber) {

this.printer = printer;

this.jobNumber = jobNumber;

public void run() {

printer.printJob(jobNumber);

}
public class Main {

public static void main(String[] args)

{ Printer printer = new Printer();

// Creating job threads in a non-sequential order

JobThread job1 = new JobThread(printer, 1);

JobThread job2 = new JobThread(printer, 2);

JobThread job3 = new JobThread(printer, 3);

JobThread job4 = new JobThread(printer, 4);

JobThread job5 = new JobThread(printer, 5);

job1.start();

job3.start();

job2.start();

job5.start();

job4.start();

7. class ThreadA extends Thread {

 private final String str;

private int digitCount;

public ThreadA(String str) {

this.str = str;

public void run() {

for (char ch : str.toCharArray()) {

if (Character.isDigit(ch)) {

digitCount++;

System.out.println("ThreadA: " + digitCount);

class ThreadB extends Thread {

private final String str;

private int charCount;

public ThreadB(String str) {

this.str = str;

public void run() {

 for (char ch : str.toCharArray()) {

if (Character.isAlphabetic(ch)) {

charCount++;

System.out.println("ThreadB: " + charCount);

public class Main {

public static void main(String[] args)

{ String k = "Hello123World456";

ThreadA threadA = new ThreadA(k);

ThreadB threadB = new ThreadB(k);

threadA.start();

threadB.start();

8. import java.util.Scanner;
class UserThreadPriority extends Thread {

private String k;

private char c;

public UserThreadPriority(String k, char c) {

this.k = k;

this.c = c;

public void run() {

System.out.println(getName() + ": String = " + k + ", Character = " + c);

public class Main {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

System.out.print("Enter a string: ");

String inputString = scanner.nextLine();

System.out.print("Enter a character: ");

char inputChar = scanner.next().charAt(0);

UserThreadPriority threadobj1 = new UserThreadPriority(inputString, inputChar);

UserThreadPriority threadobj2 = new UserThreadPriority(inputString, inputChar);

 threadobj1.setName("ThreadA");

threadobj2.setName("ThreadB");

threadobj1.start();

threadobj2.start();

scanner.close();

9. class SleepThread extends Thread {

private final long sleepTime;

public SleepThread(long sleepTime) {

this.sleepTime = sleepTime;

public void run() {

try {

System.out.println(getName() + " will sleep for " + sleepTime + " nanoseconds.");

Thread.sleep(sleepTime / 1_000_000); // Convert nanoseconds to milliseconds

 System.out.println(getName() + " has woken up.");

} catch (InterruptedException e)

{ Thread.currentThread().interrupt();

public class Main {

public static void main(String[] args) { SleepThread

thread1 = new SleepThread(10); SleepThread

thread2 = new SleepThread(20); SleepThread

thread3 = new SleepThread(50); SleepThread

thread4 = new SleepThread(70); SleepThread

thread5 = new SleepThread(100);

thread1.start();

thread2.start();

thread3.start();

thread4.start();

thread5.start();

}
10. class PriorityThread extends Thread {

public PriorityThread(String name) {

super(name);

public void run() {

System.out.println(getName() + " with priority " + getPriority() + " is executing.");

public class Main {

public static void main(String[] args) {

PriorityThread thread1 = new PriorityThread("Thread 1");

PriorityThread thread2 = new PriorityThread("Thread 2");

PriorityThread thread3 = new PriorityThread("Thread 3");

PriorityThread thread4 = new PriorityThread("Thread 4");

PriorityThread thread5 = new PriorityThread("Thread 5");

// Set thread priorities

 thread1.setPriority(Thread.MIN_PRIORITY); // 1

thread2.setPriority(Thread.NORM_PRIORITY); // 5

thread3.setPriority(Thread.MAX_PRIORITY); // 10

thread4.setPriority(Thread.MIN_PRIORITY); // 1

thread5.setPriority(Thread.NORM_PRIORITY); // 5

// Start threads

thread1.start();

thread2.start();

thread3.start();

thread4.start();

thread5.start();