Java线程通讯方法之wait()、nofity() 详解

Java线程通讯方法之wait()、nofity() 详解

本文将探讨以下问题：

1. synchronized 代码块使用
2. notify()与notifyAll()的区别
3. Java wait(),notify()如何使用

参考文章:

Java并行(2): Monitor

Java并发编程：线程间协作的两种方式：wait、notify、notifyAll和Condition

Java的wait(), notify()和notifyAll()使用心得

原创文章，欢迎转载!

synchronized 代码块使用

 我们知道当多个线程同时访问一个线程安全方法时我们可以使用synchronized关键字来给方法加锁。当某个线程需

要访问方法时,会先获取访问该方法的锁，当访问完毕再释放锁。当多个线程在等待调用队列中，操作系统根据一

定的调度算法，取出下一个线程来执行方法，完成方法的并行到串行的执行过程。每个对象都拥有一个Monitor，我

们可以将Monitor理解为对象的锁。每个线程访问任意对象时必须要先获取该对象的Monitor 才能访问。当synchro-

nized修饰一个对象时，它控制多线程访问该对象的方法正是通过对象的Monitor实现。请看下面计数代码：

public class SynchronizedImpl implements Runnable{
    public static  MyInteger num = new MyInteger() ;
    public void run() {
        // 锁定 num 引用的对象
        synchronized (num){
            // 对num 的成员变量value自增,步进为1
            num.setValue(num.getValue()+1);
            System.out.println(Thread.currentThread().getName()+":"+SynchronizedImpl.num.getValue());
        }
    }
    public static void main(String[] args) {
        for(int i =0 ; i < 1000 ;i++){
                Thread t =  new Thread(new SynchronizedImpl());
                t.start();
        }
    }
}
class MyInteger{
    int value =0 ;
    public int getValue() {
        return value;
    }
    public void setValue(int value) {
        this.value = value;
    }
}

 上述代码 num 所引用的对象(ps: 事实上num 并不是一个对象，只是栈中的一个引用，记录的是它所引用的对象的地址，下

文为了叙述方便把num 称为对象) ，同时被多个线程访问。（ps:事实上不会是1000个线程同时访问，同时访问一个对象的

线程数小于等于cpu的核心数）。

从打印的结果来看，虽然线程并不是顺序执行，但是保证每个线程都访问一次num对象，并且对num对象的 value 属性 +1 。

notify() 和notifyAll()

  顾名思义notify()是唤醒一个正在等待的线程，notifyAll()是唤醒所有正在等待的线程。这样的解释 并不会让我们很好理解

二者之间的区别。

notify()

  notify是通知操作系统唤醒一个正在等待的获取对象锁的线程,当有多个等待线程时候, 操作系统会根据一定的调度算法调

度一个线程,当正在占有对象锁的线程释放锁的时候操作系统调度的这个线程就会执行。而而剩下的那些没有被notify的线程

就不会获取执行机会。

notifyAll()

  当有多个等待线程时，所有的等待线程都会被唤醒，他们会根据操作系统的调度顺序依次执行。下面的代码说明二者的区别:

public class NofityTest implements Runnable {
    private Object lock ;
    private int num ;
    public NofityTest(Object lock, int i) {
        this.lock = lock ;
        num = i ;
    }

    @Override
    public void run() {
            synchronized(lock){
                try {
                    lock.wait();
                    System.out.println("--- "+num);
                } catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
    }

    public static void main(String[] args) {
        // 利用obj 的wait 方法实
        final  Object lock = new Object() ;
        new Thread(new NofityTest(lock,1)).start();
        new Thread(new NofityTest(lock,2)).start();
        try {
            // 等待另外两个线程进入wait状态
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (lock){
        // 请将 lock.notify() 改成lock.notifyAll() 再执行观察二者区别 !!
            lock.notify();
        }
    }
}

wait()和notify()

 对象的wait()是让当前线程释放该对象Monitor锁并且进入访问该对象的等待队列，当前线程会进入挂起状态，等待操作系统唤起(notify)

挂起的线程重新获取对该对象的访问锁才能进入运行状态。因为自身已经挂起，所以已经挂起的线程无法唤醒自己，必须通过别的线程

告诉操作系统，再由操作系统唤醒。Monitor是不能被并发访问的(否则Monitor状态会出错，操作系统根据错误的状态调度导致系统错乱)，

而wait和nofity 正是改变Monitor的状态（请参考 PV操作） 所以使用wait、notify方法时，必须对对象使用synchronized加锁，只有线程获

取对象的Monitor锁之后才能进行wait、notify操作否则将抛出IllegalMonitorStateException异常。我们来看一段代码:

    public class PrintAB implements Runnable{
      private Object lock ;
      private char ch ;
      public PrintAB(Object lock ,char ch){
          this.lock = lock ;
          this.ch = ch ;
      }
      @Override
      public void run() {
          while(true){
              synchronized (lock){
                  try {
                      /**
                       * 第一次执行并不会唤醒任何线程，
                       * 第二次以及以后就会唤醒另外一个线程获取Monitor锁，因为只有一个线程挂起
                       * 而notify() 就是唤醒一个线程
                       */
                      lock.notify();
                      System.out.println(Thread.currentThread().getName()+":"+ch);
                      /**
                       * synchronized 代码块执行完毕之后才会交出Monitor锁，别的线程才有执行机会
                       * wait 执行过之后当前线程就挂起了,然后释放锁，接着已经被操作系统notify
                       * 的线程获取Monitor 开始执行
                       */
                      lock.wait();
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
          }
      }

      public static void main(String[] args) {
          // 我们最好将 lock 声明为final ,防止重新赋值后导致synchronized锁定对象发生改变。
          final Object lock = new Object();
          new Thread(new PrintAB(lock,'A')).start();
          new Thread(new PrintAB(lock,'B')).start();
      }
  }

上述代码实现了交替打印 字符A 和字符B 。当一个线程打印完毕之后自己就会挂起，必须等待另外一个线程打印并将

之唤醒，就实现了交替打印的效果。