精华内容
下载资源
问答
  • notify和notifyAll

    2020-03-18 15:04:51
    1 对象的方法,用于唤醒等待池中的线程,将等待池中的线程唤醒至锁池; 2 notify()随机唤醒等待池中的任意一个线程至锁池,notifyAll()唤醒等待池中所有的线程至锁池 ...
    1 对象的方法,用于唤醒等待池中的线程,将等待池中的线程唤醒至锁池;
    2 notify()随机唤醒等待池中的任意一个线程至锁池,notifyAll()唤醒等待池中所有的线程至锁池
    展开全文
  • notify和notifyall

    2018-08-23 11:27:52
    锁池等待池: 锁池:假设线程A已经拥有了某个对象(注意:不是类)的锁,而其它的线程想要调用这个对象的某个synchronized方法(或者synchronized块),由于这些线程在进入对象的synchronized方法之前必...

    原文见知乎:
    作者:知乎用户
    链接:https://www.zhihu.com/question/37601861/answer/145545371
    来源:知乎

    锁池和等待池:
    锁池:假设线程A已经拥有了某个对象(注意:不是类)的锁,而其它的线程想要调用这个对象的某个synchronized方法(或者synchronized块),由于这些线程在进入对象的synchronized方法之前必须先获得该对象的锁的拥有权,但是该对象的锁目前正被线程A拥有,所以这些线程就进入了该对象的锁池中。

    等待池:假设一个线程A调用了某个对象的wait()方法,线程A就会释放该对象的锁后,进入到了该对象的等待池中

    notify和notifyAll的区别
    如果线程调用了对象的 wait()方法,那么线程便会处于该对象的等待池中,等待池中的线程不会去竞争该对象的锁。
    当有线程调用了对象的 notifyAll()方法(唤醒所有 wait 线程)或 notify()方法(只随机唤醒一个 wait 线程),被唤醒的的线程便会进入该对象的锁池中,锁池中的线程会去竞争该对象锁。也就是说,调用了notify后只要一个线程会由等待池进入锁池,而notifyAll会将该对象等待池内的所有线程移动到锁池中,等待锁竞争优先级高的线程竞争到对象锁的概率大,假若某线程没有竞争到该对象锁,它还会留在锁池中,唯有线程再次调用 wait()方法,它才会重新回到等待池中。而竞争到对象锁的线程则继续往下执行,直到执行完了 synchronized 代码块,它会释放掉该对象锁,这时锁池中的线程会继续竞争该对象锁。
    注意:
    永远在synchronized的函数或对象里使用wait、notify和notifyAll,不然Java虚拟机会生成 IllegalMonitorStateException。

    综上,所谓唤醒线程,另一种解释可以说是将线程由等待池移动到锁池,notifyAll调用后,会将全部线程由等待池移到锁池,然后参与锁的竞争,竞争成功则继续执行,如果不成功则留在锁池等待锁被释放后再次参与竞争。而notify只会唤醒一个线程。有了这些理论基础,后面的notify可能会导致死锁,而notifyAll则不会的例子也就好解释了

    展开全文
  • 主要介绍了 java notify和notifyAll的对比的相关资料,需要的朋友可以参考下
  • 本文主要介绍Java notify和notifyAll的知识,这里整理详细的资料来说明notify 和NotifAll的区别,有需要的小伙伴可以参考下
  • 您可能已经注意到Object类具有三个最终方法,分别称为wait,notify和notifyAll。这些方法用于线程间通信。Java 5引入了执行程序框架,该执行程序框架为您处理线程间通信,并在内部使用wait,notify和notifyAll。但是...

    您可能已经注意到Object类具有三个最终方法,分别称为wait,notify和notifyAll。这些方法用于线程间通信。Java 5引入了执行程序框架,该执行程序框架为您处理线程间通信,并在内部使用wait,notify和notifyAll。但是您仍然需要对这些方法以及线程间通信如何在Java中使用wait,notify和notifyAll进行基本了解。

    什么是wait,notify和notifyAll方法?

    wait,notify和notifyAll方法用于允许线程通过访问公共对象彼此通信,或者换句话说,对象可以被视为通过这些方法进行线程间通信的媒介。这些方法需要从同步上下文中调用,否则将抛出java.lang.IllegalMonitorStateException。

    同步块的一些背景:

    • 同步块中一次只能进入一个线程
    • 线程需要锁定对象才能进入同步块。
    • 如果线程A要进入同步块,则线程A必须等待线程B释放它。
    让我们对这些方法有一些简要的了解:

    wait():

    当您在对象上调用wait方法时,它告诉线程放弃锁并进入睡眠状态,除非并且直到其他线程进入同一监视器并在其上调用notify或notifyAll方法。

    notify():

    当您在对象上调用notify方法时,它将唤醒等待该对象的线程之一。因此,如果有多个线程在等待一个对象,它将唤醒其中之一。现在,您一定想知道它将唤醒哪一个。它实际上取决于OS的实现。

    notifyAll():

    notifyAll会唤醒所有在该对象上等待的线程,而不是notify会只唤醒其中一个线程,哪个线程会首先唤醒取决于线程优先级和操作系统实现。

    让我们借助示例了解它:

    1.创建一个名为Book.java的类:

    这是Java bean类,线程将在该Java bean类上作用并调用wait和notify方法。

     
     
     
     
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
     
    package org.arpit.java2blog.thread;
     
    public class Book {
     
    String title;
    boolean isCompleted;
     
    public Book(String title) {
      super();
      this.title = title;
    }
     
    public String getTitle() {
      return title;
    }
    public void setTitle(String title) {
      this.title = title;
    }
    public boolean isCompleted() {
      return isCompleted;
    }
    public void setCompleted(boolean isCompleted) {
      this.isCompleted = isCompleted;
    }
     
    }
     

    2.创建一个名为BookReader.java的类

    该线程将等到其他线程调用notify方法,然后再完成其处理。它将首先锁定书本对象,然后从同步块中调用它。因此在本示例中,它将等待BookWriter完成书本。

     
     
     
     
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
     
    package org.arpit.java2blog.thread;
     
    public class BookReader implements Runnable{
     
    Book book;
     
    public BookReader(Book book) {
      super();
      this.book = book;
    }
     
    @Override
    public void run() {
      synchronized (book) {
       System.out.println(Thread.currentThread().getName()+" is waiting for the book to be completed: "+book.getTitle());
       try {
        book.wait();
       } catch (InterruptedException e) {    
        e.printStackTrace();
       }
       System.out.println(Thread.currentThread().getName()+": Book has been completed now!! you can read it");
      }
    }
     
    }
     

    3.创建一个名为BookWriter.java的类

    此类将通知正在等待书本对象的线程(如果有notify的话)。一旦调用notify,它将不会放弃锁,它首先完成其同步块。因此,在此示例中,BookWriter将完成书籍并将其通知给BookReaders。
     

     

     
     
     
     
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
     
    package org.arpit.java2blog.thread;
    public class BookWriter implements Runnable{
     
    Book book;
     
    public BookWriter(Book book) {
      super();
      this.book = book;
    }
     
    @Override
    public void run() {
      synchronized (book) {
       System.out.println("Author is Starting book : " +book.getTitle() );
       try {
        Thread.sleep(1000);
       } catch (InterruptedException e) {
        e.printStackTrace();
       }
       book.setCompleted(true);
       System.out.println("Book has been completed now");
     
       book.notify();
       System.out.println("notify one reader");
     
      }
    }
    }
     

    4.创建一个类ThreadInterCommunicationMain,java。

    这是我们的主类,它将创建上述类的对象并运行它。

     
     
     
     
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
     
    package org.arpit.java2blog.thread;
     
    public class ThreadInterCommunicationMain {
     
    public static void main(String args[])
    {
      // Book object on which wait and notify method will be called
      Book book=new Book("The Alchemist");
      BookReader johnReader=new BookReader(book);
      BookReader arpitReader=new BookReader(book);
     
      // BookReader threads which will wait for completion of book
      Thread johnThread=new Thread(johnReader,"John");
      Thread arpitThread=new Thread(arpitReader,"Arpit");
     
      arpitThread.start();
      johnThread.start();
     
      // To ensure both readers started waiting for the book
      try {
       Thread.sleep(3000);
      } catch (InterruptedException e) {
     
       e.printStackTrace();
      }
      // BookWriter thread which will notify once book get completed
      BookWriter bookWriter=new BookWriter(book);
      Thread bookWriterThread=new Thread(bookWriter);
      bookWriterThread.start();
     
    }
     
    }
     

    在notify()的情况下:

    当您运行上述程序时,将得到以下输出:

     
     
     
     
    1
    2
    3
    4
    5
    6
    7
    8
     
    Arpit is waiting for the book to be completed: The Alchemist
    John is waiting for the book to be completed: The Alchemist
    Author is Starting book : The Alchemist
    Book has been completed now
    notify one reader
    Arpit: Book has been completed now!! you can read it
     

     

    如果是notifyAll():可以

    将BookWriter类更改为调用book.notifyAll()。

     
     
     
     
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
     
    package org.arpit.java2blog.thread;
     
    public class BookWriter implements Runnable{
     
    Book book;
     
    public BookWriter(Book book) {
      super();
      this.book = book;
    }
     
    @Override
    public void run() {
      synchronized (book) {
       System.out.println("Author is Starting book : " +book.getTitle() );
       try {
        Thread.sleep(1000);
       } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
       }
       book.setCompleted(true);
       System.out.println("Book has been completed now");
     
       book.notifyAll();
       System.out.println("notify readers");
     
      }
    }
     
    }
     

    当您运行上述程序时,将得到以下输出:

     
    1
    2
    3
    4
    5
    6
    7
    8
    9
     
    Arpit is waiting for the book to be completed: The Alchemist
    John is waiting for the book to be completed: The Alchemist
    Author is Starting book : The Alchemist
    Book has been completed now
    notify readers
    John: Book has been completed now!! you can read it
    Arpit: Book has been completed now!! you can read it
     

    如果是notifyAll(),它将通知所有正在等待该对象的线程。

    展开全文
  • notify和notifyall的区别

    2020-12-27 20:55:48
    调用wait的线程的唤醒,一般通过notify和notifyAll,但是两者之间有什么区别呢? 分析 线程调用synchronized方法或者synchronized代码块需要获取对象锁,如果没有获取则进入锁池 线程调用wait方法进入等待池,此时...

    场景

    • 调用wait的线程的唤醒,一般通过notify和notifyAll,但是两者之间有什么区别呢?

    分析

    1. 线程调用synchronized方法或者synchronized代码块需要获取对象锁,如果没有获取则进入锁池
    2. 线程调用wait方法进入等待池,此时可以通过锁对象调用 notify,notifyAll方法(第三方线程获取锁对象的synchronized的方法中释放),释放等待池线程进入锁池。
    3. notify只释放一个等待池中的线程,优先级的高的机会大些。而notifyAll则释放等待池中所有的线程.

    例子

    • 使用notify方法,线程T2处于死锁状态
    public class ThreadWaitAndNotifyDemo {
        public static void main(String[] args) throws InterruptedException {
            Thread thread = new Thread(ThreadWaitAndNotifyDemo::sayHelloWorld);
            thread.setName("T1");
            thread.start();
    
    
            Thread thread1 = new Thread(ThreadWaitAndNotifyDemo::sayHelloWorld);
            thread1.setName("T2");
            thread1.start();
    
    
            // 调用notify方法的对象必须和wait是同一个
            Object monitor = ThreadWaitAndNotifyDemo.class;
            synchronized (monitor) {
                monitor.notify();
            }
            
    //        thread.join();         // 等待线程结束
            System.out.println("Hello next ------->");
    
        }
    
        private static void sayHelloWorld()
        {
            Object monitor = ThreadWaitAndNotifyDemo.class;
            synchronized (monitor) {
                try {
                    System.out.printf("线程【%s】<--------------->进入等待状态 \n", Thread.currentThread().getName());
                    monitor.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.printf("线程[%s] 恢复执行: <==============> Hello World!\n", Thread.currentThread().getName());
            }
        }
    }
    
    
    线程【T1】<--------------->进入等待状态 
    线程【T2】<--------------->进入等待状态 
    Hello next ------->
    线程[T1] 恢复执行: <==============> Hello World!
    

    经典java线程状态流转图

    在这里插入图片描述

    展开全文
  • notify和notifyAll的区别

    2020-07-05 10:29:44
    想了解这两者的区别,首先要了解两个概念 锁池 EntrySet 等待池 WaitSet 锁池 等待池 notify和notifyAll的区别
  • java中的notify和notifyAll有什么区别? 关注问题写回答 Java Java 编程 Java EE Java 程序员 java中的notify和notifyAll...
  • Java中 notify和notifyAll*

    2020-09-10 08:54:26
    线程调用notify()或者notifyAll()后,线程不会释放它自己的锁,直到该synchronized包裹的方法执行完以后,它会释放锁,所以notify()和notifyAll()一般会放在同步代码块儿的最后一行 notify()和notifyAll()需要包裹...
  • wait, notify notifyAll,这些在多线程中被经常用到的保留关键字,在实际开发的时候很多时候却并没有被大家重视。本文对这些关键字的使用进行了描述。  在 Java 中可以用 wait、notify notifyAll 来实现...
  • Java中notify和notifyAll的区别 - 何时以及如何使用

    万次阅读 多人点赞 2018-07-13 18:24:34
    用Java通知vs notifyAllnotify和notifyAll方法之间有什么区别是棘手的Java问题之一,这很容易回答但是一旦访问者提出后续问题,你要么感到困惑,要么无法提供明确的答案? notify和notifyAll之间的主要区别在于...
  • 经常在网上逛,关于在java中notify和notifyAll,经常有人有以下的说法: notify只会通知一个在等待的对象,而notifyAll会通知所有在等待的对象,并且所有对象都会继续运行 并且,好像都有例子可以证明。上面的说法,...
  • 6、notify notifyAll的区别 notify方法只唤醒一个等待(对象的)线程并使该线程开始执行。所以如果有多个线程等待一个对象,这个方法只会唤醒其中一个线程,选择哪个线程取决于操作系统对多线程管理的实现。...
  • Object对象的wait、notify和notifyAll使用方法 一.先说答案,再进行讲解 二.正确示例 三.错误示例1 四.错误示例2 Object对象的wait、notify和notifyAll使用方法 Object的wait、notify 和 notifyAll是Object提供...
  • 问题:notify和notifyall的区别? -----》1、notifyAll会让所有处于等待池的线程全部进入锁池去竞争获取锁的机会 2、notify只会随机选取一个处于等待池的线程进入锁池去竞争获取锁的机会 public class ...
  • 本文转载自两篇博文,返回主页三月烟雨飘摇的南方 和你真的懂wait、notify和notifyAll吗 将两篇文章的内容合并在一起了,方便以后自己看。 首先先说一下相关知识点和结论: 1、wait()、notify/notifyAll() 方法是...
  • notify和notifyall有什么区别一直不是很清楚,做了如下测试: public class SignalAllTest { public static void main(String[] args) { Object lock = n...
  • 经常在网上逛,关于在java中notify和notifyAll,经常有人有以下的说法:notify只会通知一个在等待的对象,而notifyAll会通知所有在等待的对象,并...
  • 经常在往上逛,关于在java中notify和notifyAll,经常有人有以下的说法: notify只会通知一个在等待的对象,而notifyAll会通知所有在等待的对象,并且所有对象都会继续运行 并且,好像都有例子可以证明。上面的说法...
  • Java notify和notifyAll源码分析与性能对比 一、源码剖析 首先,看看在synchronizer.cpp中notify和notifyall的实现: void ObjectSynchronizer::notify(Handle obj, TRAPS) { if (UseBiasedLocking) { ...
  • 如何在 Java 中正确使用 wait, notify notifyAll – 以生产者消费者模型为例 2015/08/04 | 分类: 基础技术 | 7 条评论 | 标签: NOTIFYNOTIFYALL, WAIT 分享到: 本文由 ImportNew...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,727
精华内容 1,490
关键字:

notify和notifyall