Methods wait(), notify(), notifyAll() in Java

These methods are defined in the Object class and are intended for interaction between threads during inter-thread synchronization.

  • wait(): frees the monitor and puts the calling thread in a wait state until another thread calls the notify()/notifyAll() method;
  • notify(): continues the work of the thread on which the wait() method was previously called;
  • notifyAll(): resumes all threads on which wait() was previously called.

When the wait() method is called, the thread releases the lock on the object and transitions from the Running state to the Waiting state. The notify() method signals one of the threads waiting on the object to go into the Runnable state. However, it is impossible to determine which of the waiting threads should become operational. The notifyAll() method causes all waiting threads for the object to return to the Runnable state. If no threads are waiting on the wait() method, then nothing happens when notify() or notifyAll() is called.

A thread can call the wait() or notify() methods on a specific object only if it currently has a lock on that object. wait(), notify() and notifyAll() should only be called from synchronized code.

Difference between notify() and notifyAll()

The fact is that several threads can simultaneously "hang" on the wait() method of one monitor. When notify() is called, only one of them exits wait() and tries to capture the monitor, and then continues with the next statement after wait(). Which one will come out is unknown in advance. And when notifyAll() is called, all threads hanging on wait() exit wait(), and they all try to capture the monitor. It is clear that at any given time the monitor can be captured by only one thread, and the rest are waiting for their turn. The order of the queue is determined by the Java thread scheduler.

Why are wait() and notify() methods only called in a synchronized block?

The monitor must be captured explicitly (via a synchronized block), because the wait() and notify() methods are not synchronized.

How does the wait() method work differently with a parameter and without a parameter?

wait()

  • with no parameters frees the monitor and puts the calling thread in a wait state until another thread calls the notify()/notifyAll() method
  • with parameters will cause the thread to wait a specified amount of time or call notify()/notifyAll()

Difference between Thread.sleep() and Thread.yield() methods

The yield() method causes the thread to transition from the running state to the runnable state, allowing other threads to wake up. However, the next selected thread to run may not be different.

The sleep() method causes the current thread to sleep for a specified time, the state changes from running to waiting.

Method Thread.join()

When a thread calls join() on another thread, the current running thread will wait until the other thread it is joining has finished:

void join()        
void join(long millis) 
void join(long millis, int nanos)

Read also:


Comments

Post a Comment

Popular posts from this blog

Methods for reading XML in Java

Image
DOM (Document Object Model) - object - reads XML, recreating it in memory in the form of an object structure, while the XML document is represented as a set of tags - nodes. Each node can have an unlimited number of child nodes. Each child can also contain several levels of descendants or none at all. Thus, the result is a kind of tree. Pluses: Easy to program. If there are many objects in XML with cross-references to each other, it is enough to go through the document twice: first time create objects without references and fill in the name-object dictionary, the second time - restore links. If an error occurs in XML, a half-created XML structure remains in memory, which will be automatically destroyed. Suitable for both reading and writing. Minuses: Low speed. Wastes a lot of memory. SAX (Simple API for XML) - event-driven - reads an XML document, responding to emerging events (opening or closing tag, string, attribute) by calling the event handlers provided by the appl...
Read more

XML, well-formed XML and valid XML

Image
XML, the eXtensible Markup Language, is a language with a simple formal syntax, well suited for creating and manipulating documents with programs, and at the same time easy to read and create documents by humans. XML is extensible, it does not fix the markup used in documents, and the developer is free to create markup in accordance with the needs of a particular area, being limited only by the syntax rules of the language. DTD A DTD, Document Type Definition, is a predefined set of rules that defines the relationships between elements and attributes. For example, the DTD for HTML says that the DIV tag must be inside the BODY tag and can appear multiple times, TITLE - in HEAD and only once, and SCRIPT - both there and there as many times as you want. A DTD is usually described directly in the document as a formulation line starting with <!DOCTYPE ... > or in a separate file. Difference between well-formed XML and valid XML Depending on the level of compliance, the document...
Read more

ArrayList and LinkedList in Java, memory usage and speed

Image
How much extra memory is needed when calling ArrayList.add()? If there is enough space in the array to accommodate a new element, then no additional memory is required. Otherwise, a new array is created, 1.5 times larger than the existing one (this is true for JDK above 1.7, in earlier versions the size of the increase is different). How much extra memory is allocated when you call LinkedList.add()? One new instance of the nested Node class is created. How much memory to store one byte primitive in LinkedList? Each LinkedList element stores a link to the previous element, the next element, and a data link. private static class Node<E> { E item; Node<E> next; Node<E> prev; //... } For 32-bit systems, each link is 32 bits (4 bytes). The object (header) of the nested Node class itself takes 8 bytes. 4 + 4 + 4 + 8 = 20 bytes, and since the size of each object in Java is a multiple of 8, so we get 24 bytes. A byte primitive occupies 1 by...
Read more