奇数偶数序列Java 2线程

Question

I am trying to write a program with two Java threads. One shall print odd and the other shall print even numbers. The output should be in sequence. My code is not working properly. Please correct it and tell me what was the error.

public class App {

  public static void main(String[] args) {
    ThrdO to=new ThrdO();
    Thread t1=new Thread(to);

    ThredE te=new ThredE();
    Thread t2=new Thread(te);
    t1.start();


    t2.start();
 }

}

public class ThrdO implements Runnable{

  PrintCl pcl =new PrintCl();

  @Override
  public void run() {
    for(int i=0;i<10;i+=2)
    pcl.Even(i);    
  }
}


public class ThredE implements Runnable {

    PrintCl pcl =new PrintCl();

    @Override
    public void run() {
      for(int i=1;i<10;i+=2)
        try {
          pcl.odd(i);
        } catch (InterruptedException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
        }   
     }

public class PrintCl {
    public void Even(int n) {
      synchronized (this) {
        System.out.println(n);
        this.notifyAll();
        try {
            this.wait();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
      }         
    }

    public void odd(int n) throws InterruptedException {

        synchronized (this) {
          System.out.println(n);
          this.notifyAll();
          this.wait();  
        }
    }
}

getting output

0 ,1

Answer 1

This is a much cleaner way of achieving what you want, without ugly sleeps in the code, not to mention that it will run faster than code with a sleep in it, for obvious reasons.

public class App {

    public static void main(String[] args) {
        PrintCl pcl = new PrintCl();

        Thread t1 = new Thread(new ThrdEven(pcl));
        Thread t2 = new Thread(new ThrdOdd(pcl));

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

public class ThrdEven implements Runnable {

    private PrintCl pcl = null;

    public ThrdEven(PrintCl pcl) {
        this.pcl = pcl;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i += 2) {
            pcl.Even(i);
        }
    }
}

public class ThrdOdd implements Runnable {

    private PrintCl pcl = null;

    public ThrdOdd(PrintCl pcl) {
        this.pcl = pcl;
    }

    @Override
    public void run() {
        for (int i = 1; i < 10; i += 2) {
            pcl.odd(i);
        }
    }
}

public class PrintCl {

    private final Object _lock = new Object();
    private boolean isEvenAllowed = true;

    public void Even(int n) {
        synchronized (this._lock) {
            while (!this.isEvenAllowed) {
                try {
                    this._lock.wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    throw new RuntimeException(e);
                }
            }
            System.out.println(n);
            this.isEvenAllowed = false;
            this._lock.notifyAll();
        }
    }

    public void odd(int n) {
        synchronized (this._lock) {
            while (this.isEvenAllowed) {
                try {
                    this._lock.wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    throw new RuntimeException(e);
                }
            }
            System.out.println(n);
            this.isEvenAllowed = true;
            this._lock.notifyAll();
        }
    }
}

Answer 2

Please try following changes in your code:

public class App {

  public static void main(String[] args) throws InterruptedException {

  PrintCl pcl =new PrintCl();

  ThrdO to=new ThrdO();
  to.setPcl(pcl);
  Thread t1=new Thread(to);

  ThredE te=new ThredE();
  te.setPcl(pcl);
  Thread t2=new Thread(te);
  t1.start();
  Thread.sleep(1000);
  t2.start();

 }
}

And for Thrd0:

public class ThrdO implements Runnable  {

  PrintCl pcl =null;

  @Override
  public void run() {
    for(int i=0;i<10;i+=2)
    pcl.Even(i);

  }

  public PrintCl getPcl() {
    return pcl;
  }

  public void setPcl(PrintCl pcl) {
    this.pcl = pcl;
  }


}

ThredE:

public class ThredE implements Runnable {

  PrintCl pcl =null;

  @Override
  public void run() {
    for(int i=1;i<10;i+=2)
        try {
            pcl.odd(i);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

  }

  public PrintCl getPcl() {
    return pcl;
  }

  public void setPcl(PrintCl pcl) {
    this.pcl = pcl;
  }
}

Answer 3

Your code has two basic problems

1. Every thread have its own printing resource . Hence once printing their first number they are waiting for notification endlessly.
2. Once you will fix this issue , Another issue is your one thread will be finished but second thread would still be waiting for its notification and it will never die.

I have fixed both issues in below code

 public class Test {
    public static void main(String[] args) throws InterruptedException {

        PrintCl pcl =new PrintCl();
        ThrdO to=new ThrdO(pcl);
        Thread t1=new Thread(to);

        ThredE te=new ThredE(pcl);
        Thread t2=new Thread(te);
        t1.start();
        Thread.sleep(1000);// just to ensure that T1 should start first
        t2.start();
    }


}
class ThrdO implements Runnable{


    private PrintCl pcl;

    public ThrdO(PrintCl pcl) {
        this.pcl = pcl;
    }

    @Override
    public void run() {
        for(int i=0;i<10;i+=2) {
            try {
                pcl.Even(i);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        synchronized (pcl){
            System.out.println("Releasing lock on pcl");
            pcl.notify();
        }
        System.out.println("ThrdO has finished its working");
    }
}

class ThredE implements Runnable {

    PrintCl pcl ;

    public ThredE(PrintCl pcl) {

        this.pcl = pcl;
    }

    @Override
    public void run() {
        for (int i = 1; i < 10; i += 2) {
            try {
                pcl.odd(i);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        synchronized (pcl){
            System.out.println("Releasing lock on pcl ");
            pcl.notify();
        }
        System.out.println("ThredE has finished its working");

    }
}

    class PrintCl {
        public void Even(int n) throws InterruptedException {
            synchronized (this) {
                System.out.println("even - "+n);
                this.notifyAll();
                    this.wait();
            }
        }

        public void odd(int n) throws InterruptedException {

            synchronized (this) {
                System.out.println("odd "+n);
                this.notifyAll();
                this.wait();
            }
        }
    }