Print Odd and Even Numbers by Two Threads in Java

Multithreading is a powerful concept in Java that allows us to create concurrent programs, making efficient use of available resources. One classic example to understand multithreading is printing odd and even numbers using two separate threads. In this section, we will explore how to achieve this in Java and discuss the concepts involved.

The Problem Statement

The goal is to create two threads, one for printing odd numbers and another for printing even numbers, in an alternating fashion. The threads should synchronize their output to ensure that the numbers are printed in the correct order.

Java Threads

In Java, we can create threads by either extending the Thread class or by implementing the Runnable interface. We will use the latter approach as it allows for more flexibility in sharing resources and promoting good object-oriented design.

Here's a basic outline of the solution:

Create a shared resource (an instance of a class) that contains the current number to be printed and a synchronization mechanism to coordinate the two threads.
Create two separate threads, one responsible for printing odd numbers and the other for printing even numbers. These threads will operate on the shared resource.
Each thread will print the current number, increment the number, and notify the other thread to start printing.

Filename: PrintOddEvenUsingThreads.java

class SharedResource {
    private int currentNumber = 1;
    private final Object lock = new Object();
    public void printOdd() {
        synchronized (lock) {
            while (currentNumber <= 10) {
                if (currentNumber % 2 == 1) {
                    System.out.println("Odd: " + currentNumber);
                    currentNumber++;
                    lock.notify();
                } else {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                }
            }
        }
    }
    public void printEven() {
        synchronized (lock) {
            while (currentNumber <= 10) {
                if (currentNumber % 2 == 0) {
                    System.out.println("Even: " + currentNumber);
                    currentNumber++;
                    lock.notify();
                } else {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                }
            }
        }
    }
}
public class PrintOddEvenUsingThreads {
    public static void main(String[] args) {
        SharedResource resource = new SharedResource();
        Thread oddThread = new Thread(() -> {
            resource.printOdd();
        });
        Thread evenThread = new Thread(() -> {
            resource.printEven();
        });
        oddThread.start();
        evenThread.start();
        try {
            oddThread.join();
            evenThread.join();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

Output:

Odd: 1
Even: 2
Odd: 3
Even: 4
Odd: 5
Even: 6
Odd: 7
Even: 8
Odd: 9
Even: 10

Explanation: We create a SharedResource class that contains the current number to be printed and a synchronization mechanism using an object called lock. The printOdd() and printEven() methods in the SharedResource class are synchronized using the lock object. Each method prints the current number, increments it, and notifies the other thread to start printing.

In the PrintOddEvenUsingThreads class, we create two threads, one for printing odd numbers and the other for printing even numbers. These threads operate on the SharedResource instance. We start the threads and use the join method to ensure that both threads complete before the main thread terminates.

We used the synchronized keyword and a shared lock object to ensure that the printOdd() and printEven() methods are executed in a mutually exclusive manner. It prevents the threads from interfering with each other and ensures that they print the numbers alternately.

Conclusion

Creating a program that prints odd and even numbers using two threads in Java involves synchronization and coordination between the threads. By using a shared resource and synchronization mechanisms, we ensure that the threads alternate their output in a controlled manner. The example provides a practical introduction to multithreading concepts and synchronization in Java, demonstrating how to tackle a classic concurrent programming problem.

Next TopicScoped value in Java

← prev next →