Java线程通信之wait-notify通信方式详解

针对题目“Java线程通信之wait-notify通信方式详解”的完整攻略，以下是详细讲解。

标题

在文章中，应该清晰地使用标题来分隔内容，以便读者可以快速浏览和导航整篇文章。

介绍

在这个部分，我们将简要介绍Java中的线程通信和wait-notify通信方式。线程通信是指多个线程之间的协作和通信，为了互相通信和协调，线程需要一些机制，而wait-notify就是Java中常用的线程通信方式之一。

wait-notify通信方式

wait-notify是基于对象监视器的一种线程通信方式，在Java对象中，每一个对象都有一个锁或者监视器。wait-notify机制是基于这个锁或者监视器，一个线程可以调用wait()方法进入等待状态，另一个线程可以调用notify()或者notifyAll()方法来唤醒它。

wait()方法的作用是使当前线程进入等待状态，并释放它所持有的对象锁。当另一个线程调用notify()或者notifyAll()时，等待线程就会被唤醒，重新竞争对象锁。

notify()方法则是唤醒该对象的一个线程（任意一个），notifyAll()则是唤醒该对象的所有线程。

示例说明一

下面的例子展示了如何使用wait()和notify()方法同步两个线程的操作。

class ThreadA implements Runnable {
  public void run() {
    synchronized(this) {
      System.out.println("ThreadA starts running...");
      try {
        // 等待一秒钟
        wait(1000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      System.out.println("ThreadA completes.");
    }
  }
}

class ThreadB implements Runnable {
  ThreadA a;

  ThreadB(ThreadA a) {
    this.a = a;
  }

  public void run() {
    synchronized(a) {
      System.out.println("ThreadB starts running...");
      // 唤醒线程A
      a.notify();
      System.out.println("ThreadB completes.");
    }
  }
}

public class MainClass {
  public static void main(String[] args) {
    ThreadA a = new ThreadA();    
    ThreadB b = new ThreadB(a);

    new Thread(a).start();
    new Thread(b).start();
  }
}

输出结果：

ThreadA starts running...
ThreadB starts running...
ThreadB completes.
ThreadA completes.

在这个例子中，ThreadA和ThreadB是两个独立的线程，ThreadB唤醒了ThreadA，但是ThreadA在等待1秒钟之后才继续执行，说明wait()方法确实是使线程进入等待状态同时释放对象锁。

示例说明二

下面的例子展示了多线程环境下，如何让线程在特定条件下等待，当条件满足时，唤醒等待的线程。

public class WaitNotifyDemo {
    static boolean condition = false;

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread() {
            @Override
            public void run() {
                synchronized (WaitNotifyDemo.class) {
                    while (!condition) {
                        try {
                            System.out.println("Thread1 waiting...");
                            WaitNotifyDemo.class.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
                System.out.println("Thread1 completes");
            }
        };

        Thread thread2 = new Thread() {
            @Override
            public void run() {
                synchronized (WaitNotifyDemo.class) {
                    condition = true;
                    System.out.println("Thread2 notifies...");
                    WaitNotifyDemo.class.notify();
                }
                System.out.println("Thread2 completes");
            }
        };

        thread1.start();

        Thread.sleep(1000);

        thread2.start();

        thread1.join();
        thread2.join();
    }
}

输出结果：

Thread1 waiting...
Thread2 notifies...
Thread1 completes
Thread2 completes

在这个例子中，Thread1和Thread2是两个独立的线程，Thread1在等待condition变量为true时进入等待状态，Thread2将condition变量设置为true，并唤醒了Thread1。最后，两个线程都执行完成。

总结

通过以上介绍和示例说明，我们了解到了Java中wait-notify机制的基本概念、实现原理和使用方法。在多线程编程中，线程通信是非常重要的一部分，合理使用wait-notify机制可以有效地实现线程之间的同步和协作，避免了不必要的CPU资源消耗和线程冲突。