Question

我无法理解locks，wait方法和notify方法的工作方式。

根据我的理解，如果在一个线程上调用x.wait()，它将等到另一个线程调用x.notify()。从那时起，一切都将按照通常的方式进行。我的代码应该做的只是在线程中打印i，然后暂停并等待直到通知线程。但是出了点问题。我使用了错误的锁吗？

class X {
        private Thread thread;
        private boolean isPaused;

        public X() {
            isPaused = false;

            this.thread = new Thread(new Runnable() {
                @Override
                public synchronized void run() {
                    for (int i = 0; i < 10; i++) {
                        System.out.println(i);
                        pause();
                        waitTillUnpaused();

                    }
                }
            });

            System.out.println("Starting the thread");
            this.thread.start();


            unpause();

            waitTillPaused();
            unpause();

            waitTillPaused();
            unpause();

            waitTillPaused();
            unpause();

            waitTillPaused();
            unpause();

            waitTillPaused();
            unpause();

            System.out.println("End");
        }

        public void waitTillUnpaused() {
            synchronized (thread) {
                try {
                    while (isPaused) {
                        thread.wait();
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

        public void pause() {
            synchronized (thread) {
                isPaused = true;
            }
        }

        public void waitTillPaused() {
            synchronized (thread) {
                while (!isPaused) {
                }
            }
        }

        public void unpause() {
            synchronized(thread){
                isPaused = false;
                thread.notifyAll();
            }
        }
    }

Answer 1

是的，你使用了错误的锁。改变你的代码：

    private volatile boolean isPaused;
...
    public void waitTillPaused() {
            while (!isPaused) {
            }
    }

以下内容：

   public void pause() {
        synchronized (thread) {  // lock thread
            isPaused = true;
        }
    }

    public void waitTillPaused() { // lock thread
        synchronized (thread) {
            while (!isPaused) {
            }
        }
    }

方法waitTillPaused锁定线程，方法pause wait永远解锁，它是一个死锁。当您使用wait时，它会解锁线程，但如果您使用以下内容：

synchronized (thread) {
      while (!isPaused) {
      }
}

线程根本没有解锁。

暂停和取消暂停一个帖子

1 个答案: