使用两个线程依次使用自定义锁打印号码，其中一个正在打印，而另一个正在打印奇数

Question

There are two threads,one is to print even numbers another prints odd numbers. With the help of below custom lock i want to print number in sequence. The problem is after printing some numbers(displayed number are in correct sequence.) threads are getting deadlocked.I spent more then an hour still unable to find issue,for me everything seems fine.

public class Main{
       public static void main(String[] args){
           Lock lock=new Lock();
           SharedData sharedData=new SharedData(lock);

           Thread th1=new Thread(new EvenWriter(sharedData));
           Thread th2=new Thread(new OddWriter(sharedData));

           th1.start();
           th2.start();
       } 
    }
    class SharedData{
        Lock lock;
        boolean printOdd;
        SharedData(Lock lock){
           this.lock=lock;
           this.printOdd=true;
        }
    }
    class OddWriter implements Runnable{
        SharedData sharedData;
        int num;
        Lock lock;
        public OddWriter(SharedData sharedData){
           this.sharedData=sharedData;
           this.num=1;
           this.lock=sharedData.lock;
        }
        public void run(){
           while(true){
             if(sharedData.printOdd){
               lock.lock();
               System.out.println(num);
               num=num+2;
               sharedData.printOdd=false;
               lock.unlock();
            }
           }
        }
    }
    class EvenWriter implements Runnable{
        SharedData sharedData;
        int num;
        Lock lock;
        public EvenWriter(SharedData sharedData){
           this.sharedData=sharedData;
           this.num=2;
           this.lock=sharedData.lock;
        }
        public void run(){
           while(true){
             if(!sharedData.printOdd){
               lock.lock();
               System.out.println(num);
               num=num+2;
               sharedData.printOdd=true;
               lock.unlock();
            }
           }
        }
    }
    class Lock{

        private boolean locked=false;
        public synchronized void lock(){

            while(locked){
               try{
                 wait();
               }
               catch(Exception e){
                   e.printStackTrace();
               }
            }

            locked=true;
        }
        public synchronized void unlock(){
            locked=false;
            try{
              notifyAll();
            }
            catch(Exception e){
               e.printStackTrace();
            }
        }
    }

Answer 1

You need to make printOdd volatile , eg

class SharedData{
    Lock lock;
    volatile boolean printOdd;
    SharedData(Lock lock) {
       this.lock=lock;
       this.printOdd=true;
    }
}

This is because you use printOdd across multiple threads; the purpose of volatile is to ensure that a piece of memory is accessible by all threads. What you were doing before was allowing access of printOdd to just the OddWriter thread, because it was the first thread to access it.

Answer 2

the data that is shared between two thread is to be atomic. Here in your case the boolean printOdd is shared between the thread which is the cause for the deadlock. Can you used

AtomicBoolean printOdd;