Print Even and Odd number in the sequence by two threads in java
Thread-1 1
Thread-0 2
Thread-1 3
Thread-0 4
Thread-1 5
Thread-0 6
Thread-1 7
Thread-0 8
Thread-1 9
Thread-0 10
Printing this sequence is the
coordination between the threads and this coordination can be achieved with the the help of wait and notify.
Two threads are running
simultaneously.
When one thread enters the critical
section then it checks whether odd is printed or not on the basis of the flag.
If the odd in not printed then it waits for other thread to print the odd
number and wait for notify signal and vice versa.
PrintEvenOddTester.java
public class PrintEvenOddTester {
public static void main(String[] args) {
Printer p = new Printer();
TaskEvenOdd te1 = new TaskEvenOdd(10, p, true);
TaskEvenOdd te2 = new TaskEvenOdd(10, p, false);
Thread t1 = new Thread(te1);
Thread t2 = new Thread(te2);
t1.start();
t2.start();
}
}
TaskEvenOdd.java
public class TaskEvenOdd implements Runnable
{
private int max;
private Printer print;
private boolean isEvenNumber;
public TaskEvenOdd(int max,
Printer print, boolean isEvenNumber) {
this.max = max;
this.print = print;
this.isEvenNumber = isEvenNumber;
}
@Override
public void run()
{
int number = isEvenNumber == true ? 2
: 1;
while (number <= max) {
if (isEvenNumber) {
try {
print.printEven(number);
} catch (InterruptedException e) {
// TODO Auto-generated
catch block
e.printStackTrace();
}
} else {
try {
print.printOdd(number);
} catch (InterruptedException e) {
// TODO Auto-generated
catch block
e.printStackTrace();
}
}
number = number +
2;
}
}
}
Printer.java
public class Printer {
boolean printOdd = false;
public void printEven(int n) throws InterruptedException
{
synchronized (this) {
while (!printOdd) {
wait();
}
System.out.println(Thread.currentThread().getName()
+ " " + n);
printOdd=false;
notifyAll();
}
}
public void printOdd(int n) throws InterruptedException
{
synchronized (this) {
while (printOdd) {
wait();
}
System.out.println(Thread.currentThread().getName()
+ " " + n);
printOdd=true;
notifyAll();
}
}
}
Output:
Thread-1 1
Thread-0 2
Thread-1 3
Thread-0 4
Thread-1 5
Thread-0 6
Thread-1 7
Thread-0 8
Thread-1 9
Thread-0 10
===============================================
Method
2:
Create a class named "OddEvenRunnable".
It will implement the 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”
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
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();
}
}
|
Output:
Odd 1
Even 2
Odd 3
Even 4
Odd 5
Even 6
Odd 7
Even 8
Odd 9
Even 10
================================================
