How to print even and odd numbers using threads in java

In this post, we will see how to print even and odd numbers using threads in java.

Table of Contents

Problem
Solution 1
- Print even and odd numbers using threads in java
Solution 2: Using remainder

Problem

You are given two threads. You need to print odd numbers using one thread and even numbers using another thread.You need to print in natural order up to MAX.
For example:
If MAX is 10, you need to print:

1 2 3 4 5 6 7 8 9 10

So 1 3 5 7 9 will be printed by odd thread
2 4 6 8 10 will be printed by even thread.

Solution 1

We will use wait and notify to solve how to print even and odd numbers using threads in java.

Use a variable called boolean odd. If you want to print odd number, it’s value should be true and vice versa for even number.
Create two methods printOdd() and printEven(), one will print odd numbers and other will print even numbers.
Create two threads, t2 for odd and t1 for even.
t1 will call printEven() method and t2 will call printOdd() method simultaneously.
If boolean odd is true in printEven() method, t1 will wait.
If boolean odd is false in printOdd() method, t2 will wait.

Print even and odd numbers using threads in java


package org.arpit.java2blog;

public class OddEvenPrintMain {

    boolean odd;
    int count = 1;
    int MAX = 20;

    public void printOdd() {
        synchronized (this) {
            while (count < MAX) {
                System.out.println("Checking odd loop");

                while (!odd) {
                    try {
                        System.out.println("Odd waiting : " + count);
                        wait();
                        System.out.println("Notified odd :" + count);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                System.out.println("Odd Thread :" + count);
                count++;
                odd = false;
                notify();
            }
        }
    }

    public void printEven() {

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        synchronized (this) {
            while (count < MAX) {
                System.out.println("Checking even loop");

                while (odd) {
                    try {
                        System.out.println("Even waiting: " + count);
                        wait();
                        System.out.println("Notified even:" + count);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("Even thread :" + count);
                count++;
                odd = true;
                notify();

            }
        }
    }

    public static void main(String[] args) {

        OddEvenPrintMain oep = new OddEvenPrintMain();
        oep.odd = true;
        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                oep.printEven();

            }
        });
        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                oep.printOdd();

            }
        });

        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

package org.arpit.java2blog;

public class OddEvenPrintMain {

boolean odd;

int count = 1;

int MAX = 20;

public void printOdd() {

synchronized (this) {

while (count < MAX) {

System.out.println("Checking odd loop");

while (!odd) {

try {

System.out.println("Odd waiting : " + count);

wait();

System.out.println("Notified odd :" + count);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println("Odd Thread :" + count);

count++;

odd = false;

notify();

}

public void printEven() {

try {

Thread.sleep(1000);

} catch (InterruptedException e1) {

e1.printStackTrace();

}

synchronized (this) {

while (count < MAX) {

System.out.println("Checking even loop");

while (odd) {

try {

System.out.println("Even waiting: " + count);

wait();

System.out.println("Notified even:" + count);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("Even thread :" + count);

count++;

odd = true;

notify();

}

public static void main(String[] args) {

OddEvenPrintMain oep = new OddEvenPrintMain();

oep.odd = true;

Thread t1 = new Thread(new Runnable() {

@Override

public void run() {

oep.printEven();

}

});

Thread t2 = new Thread(new Runnable() {

@Override

public void run() {

oep.printOdd();

}

});

t1.start();

t2.start();

try {

t1.join();

t2.join();

} catch (InterruptedException e) {

e.printStackTrace();

}

When you run above program, you will get below output:

Checking odd loop
Odd Thread :1
Checking odd loop
Odd waiting : 2
Checking even loop
Even thread :2
Checking even loop
Even waiting: 3
Notified odd :3
Odd Thread :3
Checking odd loop
Odd waiting : 4
Notified even:4
Even thread :4
Checking even loop
Even waiting: 5
Notified odd :5
Odd Thread :5
Checking odd loop
Odd waiting : 6
Notified even:6
Even thread :6
Checking even loop
Even waiting: 7
Notified odd :7
Odd Thread :7
Checking odd loop
Odd waiting : 8
Notified even:8
Even thread :8
Checking even loop
Even waiting: 9
Notified odd :9
Odd Thread :9
Checking odd loop
Odd waiting : 10
Notified even:10
Even thread :10
Checking even loop
Even waiting: 11
Notified odd :11
Odd Thread :11
Checking odd loop
Odd waiting : 12
Notified even:12
Even thread :12
Checking even loop
Even waiting: 13
Notified odd :13
Odd Thread :13
Checking odd loop
Odd waiting : 14
Notified even:14
Even thread :14
Checking even loop
Even waiting: 15
Notified odd :15
Odd Thread :15
Checking odd loop
Odd waiting : 16
Notified even:16
Even thread :16
Checking even loop
Even waiting: 17
Notified odd :17
Odd Thread :17
Checking odd loop
Odd waiting : 18
Notified even:18
Even thread :18
Checking even loop
Even waiting: 19
Notified odd :19
Odd Thread :19
Notified even:20
Even thread :20

If you observe output, you should be able to understand above program.

Let me try to explain first few lines:
Checking odd loop : t2 Checks for while condition in printOdd() method
Odd Thread :1 : t2 Prints the count ,increment it by one and make odd=false
Checking odd loop : Checks for while condition in printOdd() method
Odd waiting : 2: Since odd=false now, t2 will wait and releases the lock
Checking even loop: t1 checks for while condition in printEven() method
Even thread :2 : t1 prints the count,increment it by one and make odd=true
Checking even loop: t1 checks for while condition in printEven() method
Even waiting: 3: Since odd=true now, t1 will wait and releases the lock
Notified odd :3 : Since we have called notify() when we were printing Even thread 2, it will notify t2.

All other steps will follow.

Solution 2: Using remainder

You can use concept of remainder here.

If number%2==1 then Odd will print the number and increment it else will go in the wait state.
If number%2==0 then Even will print the number and increment it else will go in the wait state.

Let’s check with the help of example.

Create a class named OddEvenRunnable and implement Runnable interface.


Create a class named <code>OddEvenRunnable</code>. It will implement Runnable interface.

public class OddEvenRunnable implements Runnable{

    public int PRINT_NUMBERS_UPTO=10;
    static int  number=1;
    int remainder;
    static Object lock=new Object();

    OddEvenRunnable(int remainder)
    {
        this.remainder=remainder;
    }

    @Override
    public void run() {
        while (number < PRINT_NUMBERS_UPTO) {
            synchronized (lock) {
                while (number % 2 != remainder) { // wait for numbers other than remainder
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName() + " " + number);
                number++;
                lock.notifyAll();
            }
        }
    }
}

Create a class named <code>OddEvenRunnable</code>. It will implement Runnable interface.

public class OddEvenRunnable implements Runnable{

public int PRINT_NUMBERS_UPTO=10;

static int number=1;

int remainder;

static Object lock=new Object();

OddEvenRunnable(int remainder)

{

this.remainder=remainder;

}

@Override

public void run() {

while (number < PRINT_NUMBERS_UPTO) {

synchronized (lock) {

while (number % 2 != remainder) { // wait for numbers other than remainder

try {

lock.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + " " + number);

number++;

lock.notifyAll();

}

Create Main class named "PrintOddEvenMain"


public class PrintOddEvenMain {
    public static void main(String[] args) {

        OddEvenRunnable oddRunnable=new OddEvenRunnable(1);
        OddEvenRunnable evenRunnable=new OddEvenRunnable(0);

        Thread t1=new Thread(oddRunnable,"Odd");
        Thread t2=new Thread(evenRunnable,"Even");

        t1.start();
        t2.start();

    }
}

public class PrintOddEvenMain {

public static void main(String[] args) {

OddEvenRunnable oddRunnable=new OddEvenRunnable(1);

OddEvenRunnable evenRunnable=new OddEvenRunnable(0);

Thread t1=new Thread(oddRunnable,"Odd");

Thread t2=new Thread(evenRunnable,"Even");

t1.start();

t2.start();

}

When you run above program, you will get below output

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

This is all about printing even and odd numbers using threads in java. Please comment if the explanation is not very clear.

Was this post helpful?

Let us know if this post was helpful. Feedbacks are monitored on daily basis. Please do provide feedback as that\'s the only way to improve.

How to print even and odd numbers using threads in java

Problem

Further reading:

Wait, notify and notifyAll method in java with example

Print sequence using 3 threads in java

Solution 1

Print even and odd numbers using threads in java

Solution 2: Using remainder

Was this post helpful?

Author

Comments

Leave a Reply Cancel reply

Categories

Popular Posts

Let’s be Friends

Problem

Further reading:

Wait, notify and notifyAll method in java with example

Print sequence using 3 threads in java

Solution 1

Print even and odd numbers using threads in java

Solution 2: Using remainder

Was this post helpful?

Related posts:

Share this

Author

Comments

Leave a Reply Cancel reply

Let’s be Friends