Java Program to Print Even Odd Using Two Threads in

Thread is a part of multithreading programming. In order to write a code for printing even and odd using 2 threads, it is required that we should have knowledge of multithreading.

Now, we need to print the even and odd numbers in natural order up to MAX using two different threads. So, we have two ways to solve the problem, i.e., by using wait and notify and by using the concept of the remainder.

By Using wait and notify

In order to print the even and odd numbers using wait and notify, we use the following steps:

We create a boolean variable odd whose value should be true when we need to print an odd number.
We create two user-defined methods such as printEventNumbers() and printOddNumbers() to print even and odd numbers.
We create two threads, i.e., thread1 and thread2, for even and odd numbers simultaneously.
The thread1 will call printEvenNumbers() method and the thread2 will call printOddNumbers() method simultaneously.
The thread1 will wait till the value of boolean odd is true in printEvenNumbers().
The thread2 will wait till the value of boolean odd is false in printOddNumbers().

Let's implement the code for printing the even odd numbers using wait and notify.

PrintEvenOddExample1.java

// import required classes and package if any
import java.util.Scanner;
// create class PrintEvenOddExample1 to print even and odd numbers using two threads
public class PrintEvenOddExample1 {
    // create a boolean variable odd for even and odd numbers
    boolean odd;
    int counter = 1;	// set initial counter to 1
    int MAX;
    // create printOddNumbers() method to print odd numbers
    public void printOddNumbers() {
        // synchronized block for odd numbers
        synchronized (this) {
            while (counter < MAX) {
                System.out.println("Syncronized block call for odd numbers.");
                while (!odd) {	// use wait and notify technique within while loop
                    // call wait() method within try-catch block for
                    try {
                        // print odd that is waiting
                        System.out.println("Odd waiting : " + counter);
                        // call wait() method
                        wait();
                        //print odd that is notified
                        System.out.println("Notified odd :" + counter);
                    } catch (InterruptedException e) {
                        // handle exceptions 
                        e.printStackTrace();
                    }
                }
                // print odd thread
                System.out.println("Odd Thread :" + counter);
                // increment counter variable
                counter++;
                // set boolean odd to false
                odd = false;
                // call notify()
                notify();
            }
        }
    }
    // create printEvenNumbers() method to print even numbers
    public void printEvenNumbers() {
        // use try-catch block to sleep thread
        try {
            // stop thread for a specific time
            Thread.sleep(1000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        // synchronized block for odd numbers
        synchronized (this) {
            while (counter < MAX) {
                System.out.println("Syncronized block call for even numbers.");
                while (odd) {	// use wait and notify technique within while loop
                    // call wait() method within try-catch block for
                    try {
                        // print odd that is waiting
                        System.out.println("Even waiting : " + counter);
                        // call wait() method
                        wait();
                        //print even that is notified
                        System.out.println("Notified even :" + counter);
                    } catch (InterruptedException e) {
                        // handle exceptions 
                        e.printStackTrace();
                    }
                }
                // print odd thread
                System.out.println("Even Thread :" + counter);
                // increment counter variable
                counter++;
                // set boolean odd to false
                odd = false;
                // call notify()
                notify();
            }
        }
    }
    // main() method start
    public static void main(String[] args) {
        // create an instance of PrintEvenOddExample1
        final PrintEvenOddExample1 obj = new PrintEvenOddExample1();
        // set boolean odd to true 
        obj.odd = true;
        // create an instance of Scanner class
        Scanner sc = new Scanner(System.in);
        System.out.println("Enter MAX value:");
        obj.MAX = sc.nextInt();
        // close scanner class instance
        sc.close();
        // create thread1 to print even numbers
        Thread thread1 = new Thread(new Runnable() {
            // override run() method
            @Override
            public void run() {
                obj.printEvenNumbers();
            }
        });
        // create thread2 to print odd numbers
        Thread thread2 = new Thread(new Runnable() {
            // override run() method
            @Override
            public void run() {
                obj.printOddNumbers();
            }
        });
        // start thread1 and thread2
        thread1.start();
        thread2.start();
        // call join() method within try-catch block
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            // handle exception
            e.printStackTrace();
        }
    }
}

Output:

Java Program to Print Even Odd Using Two Threads in

By Using Remainder

In this technique of printing even and odd numbers with two threads, the code is based on the following two points:

If num%2==1, odd will print the number and increment it. Else odd will go in the wait state.
If number52==0, even will print the number and increment it. Else even will go in the wait state.

EvenOddRunnable.java

// import required classes and package if any
// create class EvenOddRunnable that implements runnable interface 
public class EvenOddRunnable implements Runnable{
    int MAX;
    static int  counter = 1;
    int rem;
    static Object lock = new Object();
    // parameterized constructor
    EvenOddRunnable(int rem, int MAX)
    {
        this.rem = rem;
        this.MAX = MAX;
    }
    // override run() method
    @Override
    public void run() {
    	// use while loop to recursively execute steps until counter < MAX
        while (counter < MAX) {
        	// synchronized block
            synchronized (lock) {
                while (counter % 2 != rem) { // wait for numbers other than remainder
                	// use try-catch block to put lock in waiting state
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName() + " " + counter);
                //increment counter
                counter++;
                lock.notifyAll();
            }
        }
    }
}

PrintEvenOddExample2.java

// import required class and package if any
import java.util.Scanner;
// create class PrintEvenOddExample2 to print even and odd numbers using 2 threads
public class PrintEvenOddExample2 {
	public static void main(String[] args) {
		int MAX;
		// create an instance of Scanner class
		Scanner sc = new Scanner(System.in);
    	System.out.println("Enter MAX value:");
    	MAX = sc.nextInt();
    	// close scanner class instance
    	sc.close();
    	// create instances of EvenOddRunnable classes
    	EvenOddRunnable runnable1 = new EvenOddRunnable(1, MAX );
    	EvenOddRunnable runnable2 = new EvenOddRunnable(0, MAX);
    	// create thread1 and thread2
        Thread thread1 = new Thread(runnable1,"Odd");
        Thread thread2 = new Thread(runnable2,"Even");       
// use start() method to start thread1 and thread2
        thread1.start();
        thread2.start();
    }
}

Output: