Task - Multithreading - Print Even Odd #41

akash-coded · 2022-02-28T03:58:25Z

akash-coded
Feb 28, 2022
Maintainer

WAP to print the even and odd numbers to a value LIMIT using two threads.

Hint - You can use a static variable, a non-static counter, two functions (one for printing even numbers, one for printing odd numbers), the synchronized block, and the notifyAll() method.

Ashwesh09 · 2022-02-28T04:32:45Z

Ashwesh09
Feb 28, 2022

package week4.MultithreadingInJava;

class TheOperation{
    int i = 1;
    public synchronized void printEven() {
        while (this.i <= 50) {
            if (i % 2 == 0) {
                System.out.println("Even :" + this.i++);
                notifyAll();
            } 
            else {
                try {
                    wait();
                }
                catch (InterruptedException e) {
                }
            }
        }
        //System.out.println("\nDone with printing even numbers.");
    }
    public synchronized void printOdd(){
        while(this.i <= 50) {
            if (i % 2 != 0) {
                System.out.println("Odd : " + this.i++);
                notifyAll();
            }
            else {
                try {
                    wait();
                }
                catch (InterruptedException e) {
                }
            }
        }
    }
}
public class EvenOdd {
    public static void main(String[] args) {
        TheOperation op = new TheOperation();
        new Thread(){
            public void run() {
                op.printEven();
            }
        }.start();
        new Thread(){
            public void run() {
                op.printOdd();
            }
        }.start();
    }
}

0 replies

Samyuktha26 · 2022-02-28T04:35:23Z

Samyuktha26
Feb 28, 2022

class Number {

    int i = 2;

    synchronized void printEven(int limit) {
        System.out.println("prints even");
        while (i <= limit) {
            System.out.print(i + " ");
            i = i + 2;
        }
        try {
            wait();
        } catch (Exception e) {
        }
    }

    synchronized void printOdd(int limit) {
        System.out.println("prints odd");
        for (int i = 1; i <= limit; i++) {
            if (i % 2 != 0) {
                System.out.print(i + " ");
            }
        }
        notifyAll();

    }
}

class ThreadEvenOdd {
    public static void main(String[] args) {
        Number n = new Number();
        final int limit = 50;

        new Thread() {
            public void run() {
                n.printEven(limit);
            }
        }.start();

        new Thread() {
            public void run() {
                n.printOdd(limit);
            }
        }.start();
    }
}

0 replies

RohitNaikade1 · 2022-02-28T04:37:16Z

RohitNaikade1
Feb 28, 2022

package Multithreading;

import java.util.Scanner;

class ParentClass {
    static int limit = 0, counter = 0;

    synchronized public void printEven() {

        while (counter < limit) {
            while (counter % 2 == 0) {
                try {
                    wait();
                } catch (Exception e) {

                }

            }
            System.out.print(counter + " ");
            counter++;
            notify();
        }
    }

    synchronized public void printOdd() {
        while (counter < limit) {
            while (counter % 2 == 1) {
                try {
                    wait();
                } catch (Exception e) {

                }
            }
            System.out.print(counter + " ");
            counter++;
            notify();
        }
    }
}

public class printEvenOdd {
    public static void main(String[] args) {
        Scanner s1 = new Scanner(System.in);
        System.out.println("Enter Limit:");
        int num = s1.nextInt();
        ParentClass.limit = num;
        ParentClass p1 = new ParentClass();
        new Thread(){
            public void run() {
                p1.printEven();
            }
        }.start();
        new Thread(){
            public void run() {
                p1.printOdd();
            }
        }.start();

    }
}

0 replies

Khyati-tripathi · 2022-02-28T04:38:08Z

Khyati-tripathi
Feb 28, 2022

package ThreadModule;

import java.util.Scanner;

class EvenOdd {
    static int count = 1;
    static int limit;

    EvenOdd(int n) {
        limit = n;
    }

    synchronized void getOddNumbers() {

        while (count < limit) {
            while (count % 2 == 0) {
                try {
                    wait();
                } catch (InterruptedException e) {

                    e.printStackTrace();
                }

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

    }

    synchronized void getEvenNumbers() {

        while (count < limit) {
            while (count % 2 != 0) {
                try {
                    wait();
                } catch (InterruptedException e) {

                    e.printStackTrace();
                }

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

    }

}

public class EvenOddDriver {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("Enter a limit ");
        int n = sc.nextInt();
        EvenOdd obj = new EvenOdd(n);
        new Thread() {
            @Override
            public void run() {
                obj.getOddNumbers();
            }
        }.start();
        new Thread() {
            @Override
            public void run() {
                obj.getEvenNumbers();
            }

        }.start();

    }
}

0 replies

ujjwal18bit1167 · 2022-02-28T04:38:15Z

ujjwal18bit1167
Feb 28, 2022

package multithreading;

class EvenOdd {
    static int LIMIT = 100;
    int i = 1;

    synchronized void printEven() {
        while (i <= LIMIT) {
            if (i % 2 == 0) {
                System.out.println("Even " + i);
                i++;

                notifyAll();
            } else {
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }

        }
    }

    synchronized void printOdd() {

        while (i <= LIMIT) {
            if (i % 2 != 0) {
                System.out.println("Odd " + i);
                i++;
                notifyAll();
            } else
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

        }
    }
}

public class PrintEvenOdd {
    public static void main(String[] args) {
        final EvenOdd evenOdd = new EvenOdd();

        Thread t1 = new Thread() {
            public void run() {
                evenOdd.printEven();
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                evenOdd.printOdd();
            }
        };

        long startTime = System.nanoTime();

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

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

        long endTime = System.nanoTime();
        long timeElapsed = endTime - startTime;
        System.out.println("Execution time in nanoseconds: " + timeElapsed);
        System.out.println("Execution time in milliseconds: " + timeElapsed / 1000000);
    }
}

0 replies

lalit-ky · 2022-02-28T04:38:26Z

lalit-ky
Feb 28, 2022

package Week4;

import java.util.Scanner;

class Print {
    synchronized void printOdd(int num) {
        for (int i = 1; i <= num; i += 2) {
            System.out.println(i);
            notifyAll();
            if (i < num) {
                try {
                    wait();
                } catch (Exception e) {

                }
            }
        }
    }

    synchronized void printEven(int num) {
        for (int i = 2; i <= num; i += 2) {
            System.out.println(i);
            notifyAll();
            if (i < num) {
                try {
                    wait();
                } catch (Exception e) {
                }
            }
        }
    }
}

public class PrintOddEven {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter Limit : ");
        final int LIMIT = scanner.nextInt();
        Print o = new Print();
        new Thread() {
            @Override
            public void run() {
                o.printOdd(LIMIT);
            }
        }.start();
        new Thread() {
            @Override
            public void run() {
                o.printEven(LIMIT);
            }
        }.start();
        scanner.close();
    }
}

0 replies

ratnadeepikavuddagiri · 2022-02-28T04:46:57Z

ratnadeepikavuddagiri
Feb 28, 2022

`package MultiThreading;
class EvenOddNumbers{
static int limit=50;
int c=1;
synchronized void printEven(){
synchronized (this) {
while (c<limit) {
while(c%2 == 0){
try {
wait();
} catch (Exception e) {
}
}
System.out.println(c);
c++;
notifyAll();
}
}
}
void printOdd(){
synchronized (this){
while (c<limit) {
while(c%2 != 0){
try {
wait();
} catch (Exception e) {
}
}
System.out.println(c);
c++;
notifyAll();
}
}
}
}

public class EvenOddSynchronized {

public static void main(String[] args) {

    EvenOddNumbers evenOddNumbers = new EvenOddNumbers();
    new Thread() {
        public void run() {
            evenOddNumbers.printEven();
        }
    }.start();

    new Thread() {
        public void run() {
            evenOddNumbers.printOdd();
        }
    }.start();
}

}`

0 replies

ShraddhaPenshanwar · 2022-02-28T04:55:21Z

ShraddhaPenshanwar
Feb 28, 2022

`package threads_in_java;

class Numbers {

static int limit = 50;
int i = 1;

synchronized void evenNumber() {
    // System.out.println("The even Numbers are");
    // for (int i = 1; i <= limit; i++) {
    // if (i % 2 == 0) {
    // System.out.println(i);
    // }
    // }

    while (i <= limit) {
        if (i % 2 == 0) {
            System.out.println("Even " + i);
            i++;

            notifyAll();
        } else {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

    }

}

synchronized void oddNumber() {
    // System.out.println("The odd Numbers are");
    // for (int i = 1; i <= limit; i++) {
    // if (i % 2 != 0) {
    // System.out.println(i);
    // }
    // }
    while (i <= limit) {
        if (i % 2 != 0) {
            System.out.println("Odd " + i);
            i++;
            notifyAll();
        } else
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

    }

}

}

class Thread1 extends Thread {

Numbers num;

Thread1(Numbers obj) {

    this.num = obj;
}

public void run() {

    synchronized (num) {
        // synchronizing the snd object
        num.evenNumber();
    }
}

}

class Thread2 extends Thread {

Numbers num;

Thread2(Numbers obj) {

    this.num = obj;
}

public void run() {

    synchronized (num) {
        // synchronizing the snd object
        num.oddNumber();
    }
}

}

public class SynchronizationTask {

public static void main(String args[]) {
    Numbers obj = new Numbers();// only one object
    Thread1 t1 = new Thread1(obj);
    Thread2 t2 = new Thread2(obj);
    t1.start();
    t2.start();
}

}`

0 replies

Gaurav-Joshi-31 · 2022-02-28T04:58:29Z

Gaurav-Joshi-31
Feb 28, 2022

class EvenOdd {
    static int limit = 50;
     int i = 1;

    synchronized void printEven() {
        while (i <= limit) {
            if (i % 2 == 0) {
                System.out.println("Even " + i);
                i++;

                notifyAll();
            } else {
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }

        }
    }

    synchronized void printOdd() {

        while (i <= limit) {
            if (i % 2 != 0) {
                System.out.println("Odd " + i);
                i++;
                notifyAll();
            } else
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

        }
    }
}

public class EvenOddSync {
    public static void main(String[] args) {
        final EvenOdd evenOdd = new EvenOdd();
        new Thread() {
            public void run() {
                evenOdd.printEven();
            }
        }.start();
        new Thread() {
            public void run() {
                evenOdd.printOdd();
            }
        }.start();
    }
}

0 replies

KaminiJha · 2022-02-28T05:01:39Z

KaminiJha
Feb 28, 2022

class Helper1 {
    static int limit = 50;
    int counter = 1;

    synchronized  void evenNum() {
        while (counter < limit) {
            if (counter % 2 == 1) {

                // Exception handle
                try {
                    wait();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            System.out.println(counter + " is even");
            counter++;
            notify();
        }
    }

    synchronized  void oddNum() {
        while (counter < limit) {
            if (counter % 2 == 0) {

                // Exception handle
                try {
                    wait();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            System.out.println(counter + " is odd");
            counter++;
            notify();
        }
    }
}

public class EvenOddThread {

    public static void main(String[] args) {
        Helper1 obj = new Helper1();
        // t1 thread for even
        new Thread() {
            public void run() {
                obj.evenNum();
            }
        }.start();

        // t2 thread for t2
        new Thread() {
            public void run() {
                obj.oddNum();
            }
        }.start();
    }
}

0 replies

RohitN09 · 2022-02-28T05:12:50Z

RohitN09
Feb 28, 2022


class PrintEvenOdd {
    static int limit;
    int i = 1;

    synchronized void printOdd() {
        while (i <= limit) {
            if (i % 2 != 0) {
                System.out.println("Thread1: " + i++);
                notifyAll();
            } else {
                try {
                    wait();
                } catch (Exception e) {
                }
            }
        }
    }

    synchronized void printEven() {
        while (i <= limit) {
            if (i % 2 == 0) {
                System.out.println("Thread2: " + i++);
                notifyAll();
            } else {
                try {
                    wait();
                } catch (Exception e) {
                }
            }
        }
    }
}

public class EvenOdd {

    public static void main(String[] args) {
        PrintEvenOdd pr = new PrintEvenOdd();

        Thread t1 = new Thread() {
            public void run() {
                PrintEvenOdd.limit = 100;
                pr.printOdd();
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                PrintEvenOdd.limit = 100;
                pr.printEven();
            }
        };

        long startTime = System.nanoTime();

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

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

        long endTime = System.nanoTime();
        long timeElapsed = endTime - startTime;
        System.out.println("Execution time in nanoseconds: " + timeElapsed);
        System.out.println("Execution time in milliseconds: " + timeElapsed / 1000000);

    }
}

0 replies

PavanArvapally · 2022-02-28T05:15:10Z

PavanArvapally
Feb 28, 2022

`
class Printer{
int limit = 50, number = 1;

synchronized void even() {
    while(number < limit){
        while(number % 2 == 1){
            try {
                wait();
            }catch (InterruptedException e){

            }
        }
        System.out.println(number++);
        notifyAll(); 
    }
}

synchronized void odd() {
    while(number < limit){
        while(number % 2 == 0){
            try {
                wait();
            }catch (InterruptedException e){

            }
        }
        System.out.println(number++);
        notifyAll(); 
    }
}

}
public class PrintEvenAndOdd {
public static void main(String[] args) {
Printer print = new Printer();
long startTime = System.nanoTime();

    new Thread(){
        public void run(){
            print.even();
        }
    }.start();

    new Thread(){
        public void run(){
            print.odd();
        }
    }.start();
}

}
`

0 replies

Samyuktha26 · 2022-02-28T05:18:08Z

Samyuktha26
Feb 28, 2022

class Number {
    int i = 1;

    synchronized void printOdd(int limit) {
        while (i < limit) {
            while (i % 2 == 0) {
                try {
                    wait();
                } catch (Exception e) {
                }
            }
            System.out.println(i++);
            notifyAll();
        }
    }

    synchronized void printEven(int limit) {
        while (i < limit) {
            while (i % 2 == 1) {
                try {
                    wait();
                } catch (Exception e) {
                }
            }
            System.out.println(i++);
            notifyAll();
        }
    }
}

class ThreadEvenOdd {
    public static void main(String[] args) {
        Number n = new Number();
        final int limit = 50;
        Thread t1 = new Thread() {
            public void run() {
                n.printOdd(limit);
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                n.printEven(limit);
            }
        };
        long startTime = System.nanoTime();
        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        } catch (Exception e) {
        }
        long endTime = System.nanoTime();
        long timeElapsed = endTime - startTime;
        System.out.println("Execution time in nanoseconds: " + timeElapsed);
        System.out.println("Execution time in milliseconds: " + timeElapsed / 1000000);
    }
}

0 replies

Amrit-Raj22 · 2022-02-28T05:23:39Z

Amrit-Raj22
Feb 28, 2022

package week4.day1;

class Number {
    static int limit;
    int i = 1;

    Number(int n) {
        Number.limit = n;
    }

    synchronized void displayOddNumbers() {
        while (i < limit) {
            while (i % 2 == 0) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    System.out.println(e);
                }
            }
            System.out.println((i++));
            notifyAll();
        }
    }

    synchronized void displayEvenNumbers() {
        while (i < limit) {
            while (i % 2 == 1) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    System.out.println(e);
                }
            }
            System.out.println((i++));
            notifyAll();
        }
    }
}

public class OddEvenThread {
    public static void main(String[] args) {
        final Number n = new Number(1000);

        Thread t1 = new Thread() {
            public void run() {
                n.displayOddNumbers();
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                n.displayEvenNumbers();
            }
        };

        long startTime = System.nanoTime();

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

        try {
            t1.join();
            t2.join();
        } catch (Exception e) {
            // TODO: handle exception
        }

        long endTime = System.nanoTime();
        long timeElapsed = endTime - startTime;
        System.out.println("Execution time in nanoseconds: " + timeElapsed);
        System.out.println("Execution time in milliseconds: " + timeElapsed / 1000000);
        System.out.println("Done!!");
    }
}

0 replies

GantaGreeshma · 2022-02-28T05:32:21Z

GantaGreeshma
Feb 28, 2022

`import java.lang.InterruptedException;

class EvenOdd {
int i = 1;

synchronized void odd(int limit) {
    while (i < limit) {
        while (i % 2 == 0) {
            try {
                wait();
            } catch (Exception e) {
            }
        }
        System.out.println(i++);
        notifyAll();
    }
}

synchronized void even(int limit) {
    while (i < limit) {
        while (i % 2 == 1) {
            try {
                wait();
            } catch (Exception e) {
            }
        }
        System.out.println(i++);
        notifyAll();
    }
}

}

public class ThreadsEvenOdd {
public static void main(String[] args) throws InterruptedException {
int number = 10;
EvenOdd evenOdd = new EvenOdd();
long startTime = System.nanoTime();
new Thread() {
@OverRide
public void run() {
evenOdd.even(number);
}
}.start();
new Thread() {
@OverRide
public void run() {
evenOdd.odd(number);
}
}.start();
long endTime = System.nanoTime();
long timeElapsed = endTime - startTime;
System.out.println("Execution time in nanoseconds: " + timeElapsed);
System.out.println("Execution time in milliseconds: " + timeElapsed / 1000000);
}
}
`

0 replies

mkaifahmed · 2022-03-01T14:11:19Z

mkaifahmed
Mar 1, 2022

package Week4.Task;

class OddThread extends Thread {
    int limit;
    sharedPrinter printer;

    public OddThread(int limit, sharedPrinter printer) {
        this.limit = limit;
        this.printer = printer;
    }

    @Override
    public void run() {
        int oddNumber = 1;
        while (oddNumber <= limit) {
            printer.printOdd(oddNumber);
            oddNumber = oddNumber + 2;
        }
    }
}

class EvenThread extends Thread {
    int limit;
    sharedPrinter printer;

    public EvenThread(int limit, sharedPrinter printer) {
        this.limit = limit;
        this.printer = printer;
    }

    @Override
    public void run() {
        int evenNumber = 2; // First even number is 2
        while (evenNumber <= limit) {
            printer.printEven(evenNumber);
            evenNumber = evenNumber + 2;
        }
    }
}

class sharedPrinter {

    boolean isOddPrinted = false;

    synchronized void printOdd(int number) {
        while (isOddPrinted) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName() + " : " + number);
        isOddPrinted = true;
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        notifyAll();
    }

    synchronized void printEven(int number) {
        while (!isOddPrinted) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName() + " : " + number);
        isOddPrinted = false;
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        notifyAll();
    }
}

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

        sharedPrinter printer = new sharedPrinter();
        OddThread oddThread = new OddThread(20, printer);
        oddThread.setName("Odd-Thread");
        EvenThread evenThread = new EvenThread(20, printer);
        evenThread.setName("Even-Thread");
        oddThread.start();
        evenThread.start();
    }
}

0 replies

Sarfinaa · 2022-03-01T14:20:39Z

Sarfinaa
Mar 1, 2022

package week_3.multithreading;

class evenodd {
    int i = 0;
    static int limit = 50;

    synchronized void printEven() throws InterruptedException {
        while (i <= limit) {
            if (i % 2 == 0) {
                System.out.println("Even:" + i++);
                notifyAll();
            } else
                wait();
        }
    }

    synchronized void printOdd() throws InterruptedException {
        while (i <= limit) {
            if (i % 2 != 0) {
                System.out.println("Odd:" + i++);
                notifyAll();
            } else
                wait();

        }
    }
}

public class EvenOddThread {
    public static void main(String[] args) {
        evenodd eo = new evenodd();
        new Thread() {
            public void run() {
                try {
                    eo.printEven();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();
        new Thread() {
            public void run() {
                try {
                    eo.printOdd();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }
}

0 replies

Shubhi27 · 2022-03-10T05:20:41Z

Shubhi27
Mar 10, 2022

package Threads;

class EvenOddCheck {
    static int limit = 50;
    int count = 1;

    synchronized void printEven() {
        while (count <= limit) {
            if (count % 2 == 0) {
                System.out.println("Even " + count);
                count++;

                notifyAll();
            } else {
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }

        }
    }

    synchronized void printOdd() {

        while (count <= limit) {
            if (count % 2 != 0) {
                System.out.println("Odd " + count);
                count++;
                notifyAll();
            } else
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

        }
    }
}

public class EvenOdd {
    public static void main(String[] args) {
        final EvenOddCheck evenOdd = new EvenOddCheck();
        new Thread() {
            public void run() {
                evenOdd.printEven();
            }
        }.start();
        new Thread() {
            public void run() {
                evenOdd.printOdd();
            }
        }.start();
    }
}

0 replies

Prem-3 · 2022-03-11T11:10:27Z

Prem-3
Mar 11, 2022

class Number {
    static int limit = 25;
    int i = 1;

    synchronized void displayOdd() {
        while (i < limit) {
            while (i % 2 != 0) {
                try {
                    wait();
                } catch (InterruptedException e) {}
            }
            System.out.println((i++));
            notifyAll();
        }
    }

    synchronized void displayEven() {
        while (i < limit) {
            while (i % 2 == 0) {
                try {
                    wait();
                } catch (InterruptedException e){}
                
            }
            System.out.println((i++));
            notifyAll();
        }
    }
}
public class ThreadEvenOrOdd {
    public static void main(String[] args) {
        final Number n = new Number();

        Thread t1 = new Thread() {
            public void run() {
                n.displayOdd();
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                n.displayEven();
            }
        };

        long startTime = System.nanoTime();

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

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

        long endTime = System.nanoTime();
        long timeElapsed = endTime - startTime;
        System.out.println("Execution time in nanoseconds: " + timeElapsed);
        System.out.println("Execution time in milliseconds: " + timeElapsed / 1000000);
    }
}

0 replies

Harshita-Joshi · 2022-03-11T14:14:34Z

Harshita-Joshi
Mar 11, 2022

package MultiThreading;

class Number {
    static int limit = 100;
    int i = 1;

    synchronized void displayOddNumbers() {
        while (i < limit) {
            while (i % 2 == 0) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    System.out.println(e);
                }
            }
            System.out.println((i++));
            notifyAll();
        }
    }

    synchronized void displayEvenNumbers() {
        while (i < limit) {
            while (i % 2 == 1) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    System.out.println(e);
                }
            }
            System.out.println((i++));
            notifyAll();
        }
    }
}
public class EvenOdd {
    public static void main(String[] args) {
        final Number n = new Number();

        Thread t1 = new Thread() {
            public void run() {
                n.displayOddNumbers();
            }
        };

        Thread t2 = new Thread() {
            public void run() {
                n.displayEvenNumbers();
            }
        };

        long startTime = System.nanoTime();

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

        try {
            t1.join();
            t2.join();
        } catch (Exception e) {
            System.out.println("Exception occurred");
        }

    }
}

0 replies

lingamurthi · 2022-08-23T16:29:45Z

lingamurthi
Aug 23, 2022

package com.lingu;



 class T{
        static int LIMIT=40;
        int i=1;
		synchronized void printeven()
		{
			
			while(i<LIMIT) 
			{
				while(i%2==0)
				{
					try {
						wait();
					} catch (Exception e) {
                     System.out.println(e);
					}
				}
				System.out.println(i++);
				notifyAll();
			}
		}
		
		
		synchronized void printodd()
		{
			
			while(i<LIMIT) 
			{
				while(i%2==1)
				{
					try {
						wait();
					} catch (Exception e) {
                     System.out.println(e);
					}
				}
				System.out.println(i++);
				notifyAll();
			}
		}
		
	}
	

class C{

	public static void main(String[] args) {

		T t=new T();
		new Thread()
		{
			@Override
			public void run() 
			{
				t.printeven();
			}
		}.start();
		
		new Thread()
		{
			@Override
			public void run() 
			{
				t.printodd();
			}
		}.start();
	}

}

0 replies

rrajbanshi · 2022-08-24T04:50:39Z

rrajbanshi
Aug 24, 2022

import java.util.*;

 interface maxLimit{
    int max = 10;
 }

 class EvenThread extends Thread implements maxLimit{
    @Override
    public void run(){
        for(int i = 0; i < max; i++){
            if(i % 2 == 0){
                System.out.println("Even number");
            }
        }
    }
 }

 class OddThread extends Thread implements maxLimit{
    @Override
    public void run(){
        for(int i = 0; i < max; i++){
            if(i %  2 != 0){
                System.out.println("Odd number");
            }
        }
    }
 }
 public class Discussion41{
    public static void main(String[] args) {
        EvenThread t1 = new EvenThread();
        OddThread t2 = new OddThread();
        t1.start();
        t2.start();
    }
 }

0 replies

ShravanKV2310 · 2022-08-24T04:53:58Z

ShravanKV2310
Aug 24, 2022

Code

class A{
    int i = 1;
    public synchronized void printEven() {
        while (this.i <= 50) {
            if (i % 2 == 0) {
                System.out.println("Even :" + this.i++);
                notifyAll();
            } 
            else {
                try {
                    wait();
                }
                catch (InterruptedException e) {
                }
            }
        }
    }
    public synchronized void printOdd(){
        while(this.i <= 50) {
            if (i % 2 != 0) {
                System.out.println("Odd : " + this.i++);
                notifyAll();
            }
            else {
                try {
                    wait();
                }
                catch (InterruptedException e) {
                }
            }
        }
    }
}
public class EvenOddNumbers {
    public static void main(String[] args) {
        A a1 = new A();
        new Thread(){
            public void run() {
                a1.printEven();
            }
        }.start();
        new Thread(){
            public void run() {
                a1.printOdd();
            }
        }.start();
    }
}

0 replies

Gauravkumar930 · 2022-08-24T04:54:12Z

Gauravkumar930
Aug 24, 2022

package p1;

public class Problem41 extends Thread{
private static final int limit=20;
@OverRide
public synchronized void run() {
Problem41 a2 = new Problem41();
a2.evenNumber();
}
public static void main(String[] args) {
Problem41 a1 = new Problem41();
a1.start();
a1.oddNumber();
}
synchronized int oddNumber() {
System.out.println("Odd Numbers are");
for (int i = 0; i < limit; i++) {
if (i%2!=0) {
System.out.print(i+" ");
notifyAll();
}else {
}
}
System.out.println();
return 0;
}
synchronized int evenNumber() {
System.out.println("Even Numbers are");
for (int i = 1; i < limit; i++) {
if (i%2==0) {
System.out.print(i+" ");
notifyAll();
}else {

		}
	}
	return 0;
}

}

0 replies

Abhishekk6 · 2022-08-24T04:55:11Z

Abhishekk6
Aug 24, 2022

class A{
    int i = 1;
    public synchronized void printEven() {
        while (this.i <= 50) {
            if (i % 2 == 0) {
                System.out.println("Even :" + this.i++);
                notifyAll();
            } 
            else {
                try {
                    wait();
                }
                catch (InterruptedException e) {
                }
            }
        }
    }
    public synchronized void printOdd(){
        while(this.i <= 50) {
            if (i % 2 != 0) {
                System.out.println("Odd : " + this.i++);
                notifyAll();
            }
            else {
                try {
                    wait();
                }
                catch (InterruptedException e) {
                }
            }
        }
    }
}
public class EvenOddNumbers {
    public static void main(String[] args) {
        A a1 = new A();
        new Thread(){
            public void run() {
                a1.printEven();
            }
        }.start();
        new Thread(){
            public void run() {
                a1.printOdd();
            }
        }.start();
    }
}

0 replies

Varunk999 · 2022-08-24T05:14:19Z

Varunk999
Aug 24, 2022

package multithreading;

public class EvenOdd{
	    static int limit = 10;
	     int i = 1;

	    synchronized void printEven() {
	        while (i <= limit) {
	            if (i % 2 == 0) {
	                System.out.println("Even " + i);
	                i++;

	                notifyAll();
	            } else {
	                try {
	                    wait();
	                } catch (InterruptedException e) {
	                    e.printStackTrace();
	                }

	            }

	        }
	    }

	    synchronized void printOdd() {

	        while (i <= limit) {
	            if (i % 2 != 0) {
	                System.out.println("Odd " + i);
	                i++;
	                notifyAll();
	            } else
	                try {
	                    wait();
	                } catch (InterruptedException e) {
	                    e.printStackTrace();
	                }

	        }
	    }
	}

0 replies

AbhishekBilagi · 2022-08-24T05:16:31Z

AbhishekBilagi
Aug 24, 2022

class Thread1 extends Thread{
	@Override
	public void run() {
		
		Program41 even=new Program41();
		even.evenNumber();
		
			
		}
		
	}


class Thread2 implements Runnable{
	@Override
	public void run() {
		
		Program41 odd=new Program41();
		odd.oddNumber();
		
	}
}
public class Program41 {
	static int limit=100;
	
	public static void main(String[] args) {
		
		Thread1 t1=new Thread1();
		t1.start();
		
		Thread2 r=new Thread2();
		Thread t2=new Thread(r);
		t2.start();
		
	}
	synchronized void evenNumber() {
		for(int i=0;i<limit;i++) {
			if(i%2==0) {
				System.out.println("Even "+i);
			}
		}
	}
	synchronized void oddNumber() {
		for(int i=0;i<limit;i++) {
			if(i%2!=0) {
				System.out.println("Odd "+i);
			}
		}
	}

}

0 replies

NavneetBais · 2022-08-24T05:20:17Z

NavneetBais
Aug 24, 2022

class printOddEven {
	public synchronized void displayEven(int num) {
		for(int i = 1 ; i <= num ; i++) {
			if( i % 2 == 0) {
				System.out.println(i + " Even Number");
				notify();
			}else {
				try {
					wait();
				} catch (InterruptedException e) {
				}
			}
			
			
		}
		
	}
	public synchronized void displayOdd(int num) {
		for(int i = 1 ; i <= num ; i++) {
			if( i % 2 != 0) {
				System.out.println(i + " Odd Number");
				notify();
			}else {
				try {
					wait();
				}catch(Exception e) {
					e.printStackTrace();
				}
			}
			
			
		}
		
	}
	
}

	




public class Driver {
	
	public static void main(String[] args) {
		printOddEven p1 = new printOddEven();
		
		new Thread() {
			public void run() {
				p1.displayEven(20);
			}
		}.start();
		
		new Thread() {
			public void run() {
				p1.displayOdd(20);
			}
		}.start();
		
	}

}

0 replies

Shivani2145 · 2022-08-24T07:16:13Z

Shivani2145
Aug 24, 2022

class Thread1 extends Thread{
	@Override
	public void run() {
		Task41 even = new Task41();
		even.evenNumber();
	}

}

class Thread2 implements Runnable{
	@Override
	public void run() {
		Task41 odd = new Task41();
		odd.oddNumber();
	}
	
}
public class Task41 {
	static int limit = 50;
	public static void main(String[] args) {
		Thread1 t1 = new Thread1();
		t1.start();
		
		Thread2 r = new Thread2();
		Thread t2 = new Thread(r);
		t2.start();
	}
	
	synchronized void evenNumber() {
		for(int i = 0; i<limit; i++) {
			if(i%2 == 0) {
				System.out.println("Even" +i);
			}
		}
	}
	
	synchronized void oddNumber() {
		for(int i = 0; i<limit; i++) {
			if(i%2!=0) {
				System.out.println("odd "+i);
			}
		}
	}
}

0 replies

Gauravkumar930 · 2022-08-27T05:55:47Z

Gauravkumar930
Aug 27, 2022

class Thread1 extends Thread{
	@Override
	public void run() {
		Task41 even = new Task41();
		even.evenNumber();
	}

}

class Thread2 implements Runnable{
	@Override
	public void run() {
		Task41 odd = new Task41();
		odd.oddNumber();
	}
	
}
public class Task41 {
	static int limit = 50;
	public static void main(String[] args) {
		Thread1 t1 = new Thread1();
		t1.start();
		
		Thread2 r = new Thread2();
		Thread t2 = new Thread(r);
		t2.start();
	}
	
	synchronized void evenNumber() {
		for(int i = 0; i<limit; i++) {
			if(i%2 == 0) {
				System.out.println("Even" +i);
			}
		}
	}
	
	synchronized void oddNumber() {
		for(int i = 0; i<limit; i++) {
			if(i%2!=0) {
				System.out.println("odd "+i);
			}
		}
	}
}

0 replies

Task - Multithreading - Print Even Odd #41

Uh oh!

akash-coded Feb 28, 2022 Maintainer

Replies: 39 comments

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Code

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

akash-coded
Feb 28, 2022
Maintainer