Java学习笔记16

Object类是所有类、数组、枚举类的父类,是类层次结构的根类。每个类都使用Object作为超类。所有对象(包括


数组)都实现这个类的方法。 


Object类实现了以下方法:


现在我们看看源码中notify()、notifyAll()、wait(long)、wait(long,int)、wait()是如何定义的:


(1)notify():


public final native void notify();

(2)notifyAll():


 public final native void notifyAll();

(3)wait(long):


public final native void wait(long timeout) throws InterruptedException;

(4)wait(long,int):


 public final void wait(long timeout, int nanos) throws InterruptedException {
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos >= 500000 || (nanos != 0 && timeout == 0)) {
            timeout++;
        }

        wait(timeout);
    }

(5) wait():


 public final void wait() throws InterruptedException {
        wait(0);
    }


(1)notify()的方法说明:


唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待,则会选择唤醒其中一个线程。选择是任


意性的,并在对实现做出决定时发生。线程通过调用其中一个wait 方法,在对象的监视器上等待。


直到当前线程放弃此对象上的锁定,才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同


步的其他所有线程进行竞争;例如,唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。


此方法只应由作为此对象监视器的所有者的线程来调用。通过以下三种方法之一,线程可以成为此对象监视器的所


有者:

  • 通过执行此对象的同步实例方法。
  • 通过执行在此对象上进行同步的 synchronized 语句的正文。
  • 对于 Class 类型的对象,可以通过执行该类的同步静态方法。

一次只能有一个线程拥有对象的监视器。


(2)notifyAll()的方法说明:


唤醒在此对象监视器上等待的所有线程。线程通过调用其中一个 wait 方法,在对象的监视器上等待。


直到当前线程放弃此对象上的锁定,才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同


步的其他所有线程进行竞争;例如,唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。


此方法只应由作为此对象监视器的所有者的线程来调用。有关线程能够成为监视器所有者的方法的描述,请参阅


notify 方法。

(3)wait(long)的方法说明:


在其他线程调用此对象的notify() 方法或 notifyAll() 方法,或者超过指定的时间量前,导致当前线程等待。


当前线程必须拥有此对象监视器。


此方法导致当前线程(称之为 T)将其自身放置在对象的等待集中,然后放弃此对象上的所有同步要求。出于线程调


度目的,在发生以下四种情况之一前,线程 T 被禁用,且处于休眠状态:

  • 其他某个线程调用此对象的 notify 方法,并且线程 T 碰巧被任选为被唤醒的线程。
  • 其他某个线程调用此对象的 notifyAll 方法。
  • 其他某个线程中断线程 T
  • 大约已经到达指定的实际时间。但是,如果 timeout 为零,则不考虑实际时间,在获得通知前该线程将一直等待。
然后,从对象的等待集中删除线程 T,并重新进行线程调度。然后,该线程以常规方式与其他线程竞争,以获得在该


对象上同步的权利;一旦获得对该对象的控制权,该对象上的所有其同步声明都将被恢复到以前的状态,这就是调


wait 方法时的情况。然后,线程 Twait 方法的调用中返回。所以,从 wait 方法返回时,该对象和线程T 的同


步状态与调用wait 方法时的情况完全相同。


在没有被通知、中断或超时的情况下,线程还可以唤醒一个所谓的虚假唤醒 (spurious wakeup)。虽然这种情况在实


践中很少发生,但是应用程序必须通过以下方式防止其发生,即对应该导致该线程被提醒的条件进行测试,如果不


满足该条件,则继续等待。换句话说,等待应总是发生在循环中,如下面的示例:


synchronized (obj) {
while (<condition does not hold>)
obj.wait(timeout);
... // Perform action appropriate to condition
     }
(4)wait(long,int)的方法说明:


在其他线程调用此对象的 notify() 方法或notifyAll() 方法,或者其他某个线程中断当前线程,或者已超过某个实际


时间量前,导致当前线程等待。


此方法类似于一个参数的 wait 方法,但它允许更好地控制在放弃之前等待通知的时间量。用毫微秒度量的实际时间


量可以通过以下公式计算出来:

1000000*timeout+nanos

在其他所有方面,此方法执行的操作与带有一个参数的 wait(long) 方法相同。需要特别指出的是,wait(0, 0)


  wait(0) 相同。


当前线程必须拥有此对象监视器。该线程发布对此监视器的所有权,并等待下面两个条件之一发生:

  • 其他线程通过调用 notify 方法,或 notifyAll 方法通知在此对象的监视器上等待的线程醒来。
  • timeout 毫秒值与 nanos 毫微秒参数值之和指定的超时时间已用完。

然后,该线程等到重新获得对监视器的所有权后才能继续执行。


对于某一个参数的版本,实现中断和虚假唤醒是有可能的,并且此方法应始终在循环中使用:


synchronized (obj) {
while (<condition does not hold>)
obj.wait(timeout, nanos);
... // Perform action appropriate to condition
     }
 


此方法只应由作为此对象监视器的所有者的线程来调用。有关线程能够成为监视器所有者的方法的描述,请参阅


notify 方法。


(5)wait()的方法说明:


在其他线程调用此对象的notify() 方法或 notifyAll() 方法前,导致当前线程等待。换句话说,此方法的行为就好像


它仅执行wait(0) 调用一样。


当前线程必须拥有此对象监视器。该线程发布对此监视器的所有权并等待,直到其他线程通过调用 notify 方法,或


  notifyAll 方法通知在此对象的监视器上等待的线程醒来。然后该线程将等到重新获得对监视器的所有权后才能继续


执行。


对于某一个参数的版本,实现中断和虚假唤醒是可能的,而且此方法应始终在循环中使用:


synchronized (obj) {
while (<condition does not hold>)
obj.wait();
... // Perform action appropriate to condition
     }
 
此方法只应由作为此对象监视器的所有者的线程来调用。有关线程能够成为监视器所有者的方法的描述,请参阅


notify 方法。  


在上面源码中关于wait(long,int)方法的实现方式。可以看出,此方法中的nanos毫微秒,只能精确到毫秒。而且这几


个方法都是由Object来实现的,也就是每个对象都有锁。


以上只是这几个方法的说明,在讲到后面的多线程时再深入举例。




转载请注明出处:http://blog.csdn.net/hai_qing_xu_kong/article/details/43917141    情绪控_ 
















©️2020 CSDN 皮肤主题: 猿与汪的秘密 设计师:上身试试 返回首页