Zwei Möglichkeiten zur Zusammenarbeit zwischen Threads in der Java-Parallelität: Warten, Benachrichtigen, NotifyAll und Bedingung
- 黄舟Original
- 2017-03-18 10:09:081223Durchsuche
Zusammenarbeit zwischen Threads. Zum Beispiel das klassischste Produzenten-Konsumenten-Modell: Wenn die Warteschlange voll ist, muss der Produzent warten, bis die Warteschlange Platz hat, bevor er weitere Waren hineinstellen kann. Während der Wartezeit muss der Produzent kritische Ressourcen freigeben (). d.h. die Warteschlange) Belegungsrecht. Denn wenn der Produzent das Recht zur Belegung kritischer Ressourcen nicht freigibt, kann der Konsument die Waren in der Warteschlange nicht verbrauchen, und in der Warteschlange ist kein Platz mehr, und der Produzent wartet auf unbestimmte Zeit. Daher wird der Produzent unter normalen Umständen, wenn die Warteschlange voll ist, aufgefordert, das Recht zur Belegung kritischer Ressourcen abzugeben und in einen angehaltenen Zustand zu wechseln. Warten Sie dann, bis der Verbraucher die Ware verbraucht hat, und teilen Sie dem Hersteller dann mit, dass in der Warteschlange Platz ist. Wenn die Warteschlange leer ist, muss der Verbraucher entsprechend darauf warten, dass der Produzent ihm mitteilt, dass sich ein Element in der Warteschlange befindet. Dieser Prozess der gegenseitigen Kommunikation ist die Zusammenarbeit zwischen Threads.
wait(), notify() und notifyAll()
[code]/**
* Wakes up a single thread that is waiting on this object's
* monitor. If any threads are waiting on this object, one of them
* is chosen to be awakened. The choice is arbitrary and occurs at
* the discretion of the implementation. A thread waits on an object's
* monitor by calling one of the wait methods
*/
public final native void notify();
/**
* Wakes up all threads that are waiting on this object's monitor. A
* thread waits on an object's monitor by calling one of the
* wait methods.
*/
public final native void notifyAll();
/**
* Causes the current thread to wait until either another thread invokes the
* {@link java.lang.Object#notify()} method or the
* {@link java.lang.Object#notifyAll()} method for this object, or a
* specified amount of time has elapsed.
* <p>
* The current thread must own this object's monitor.
*/
public final native void wait(long timeout) throws InterruptedException; 1) wait(), notify() und notifyAll( )-Methode ist eine lokale Methode und endgültig und kann nicht überschrieben werden.
2) Das Aufrufen der Methode „wait()“ eines Objekts kann den aktuellen Thread blockieren, und der aktuelle Thread muss den Monitor (d. h. die Sperre) dieses Objekts besitzen.
3) Das Aufrufen der Methode „notify()“ eines Objekts kann ein Objekt aufwecken Der Thread, der auf den Monitor dieses Objekts wartet, kann nur einer von ihnen geweckt werden Alle Monitore, die auf dieses Objekt warten, werden angezeigt.
Einige Freunde haben möglicherweise Fragen: Warum sind diese drei Methoden nicht in der Thread-Klasse deklariert, sondern Methoden, die in der Object-Klasse deklariert sind (natürlich, da die Thread-Klasse erbt). In der Object-Klasse kann Thread auch drei Methoden aufrufen. Tatsächlich ist dieses Problem sehr einfach. Da jedes Objekt über einen Monitor (dh eine Sperre) verfügt, sollte der aktuelle Thread natürlich über dieses Objekt bedient werden, wenn er auf die Sperre eines Objekts warten soll. Anstatt den aktuellen Thread für den Betrieb zu verwenden, wäre es sehr kompliziert, über Threads zu arbeiten, da der aktuelle Thread möglicherweise auf Sperren von mehreren Threads wartet.
Wie oben erwähnt: Wenn die Methode wait() eines Objekts aufgerufen wird, muss der aktuelle Thread den Monitor (d. h. die Sperre) dieses Objekts besitzen, sodass der Aufruf der Methode wait() in einem synchronisierten Block oder synchronisiert erfolgen muss Methode (synchronisierter Block oder synchronisierte Methode).
Das Aufrufen der Methode wait () eines Objekts entspricht der Aufforderung an den aktuellen Thread, den Monitor dieses Objekts zu übergeben und dann in den Wartezustand zu wechseln und auf die anschließende erneute Erfassung der Sperre dieses Objekts (Schlaf) zu warten Die Methode in der Thread-Klasse bewirkt, dass der aktuelle Thread die Ausführung für einen bestimmten Zeitraum anhält, wodurch andere Threads die Möglichkeit haben, mit der Ausführung fortzufahren. Die Objektsperre wird jedoch nicht aufgehoben.
Die notify()-Methode kann a aufwecken Thread, der auf den Monitor des Objekts wartet, wenn mehrere Threads auf das Objekt warten. Wenn der Monitor verwendet wird, kann nur einer der Threads aktiviert werden, und der spezifische Thread, der aktiviert werden soll, ist unbekannt.
Ebenso muss beim Aufrufen der notify()-Methode eines Objekts der aktuelle Thread auch den Monitor dieses Objekts besitzen, sodass der Aufruf der notify()-Methode in einem synchronisierten Block oder einer synchronisierten Methode (synchronisierter Block oder synchronisiert) erfolgen muss Verfahren).
Die Methode nofityAll() kann alle Threads wecken, die auf die Überwachung des Objekts warten, was sich von der Methode notify() unterscheidet.
Hier ist etwas zu beachten: Die Methoden notify() und notifyAll() wecken nur den Thread, der auf den Monitor des Objekts wartet, und bestimmen nicht, welcher Thread den Monitor erhalten kann.
Geben Sie ein einfaches Beispiel: Angenommen, es gibt drei Threads, Thread1, Thread2 und Thread3, die alle auf den Monitor von Objekt objectA warten. Nach dem Aufruf der Methode objectA.notify() in Thread4 , Thread1, Nur einer von Thread2 und Thread3 kann aktiviert werden. Beachten Sie, dass das Aufwachen nicht bedeutet, dass der Monitor von ObjektA sofort erhalten wird. Wenn die Methode objectA.notifyAll() in Thread4 aufgerufen wird, werden die drei Threads Thread1, Thread2 und Thread3 aktiviert. Welcher Thread als nächstes den Monitor von objectA erhalten kann, hängt von der Planung des Betriebssystems ab.
Achten Sie besonders auf das oben Genannte. Wenn ein Thread aktiviert wird, bedeutet dies nicht, dass er den Monitor des Objekts sofort erhält, nachdem er notify() oder notifyAll() aufgerufen und den synchronisierten Block verlassen und die Objektsperre aufgehoben hat Können andere Threads die Sperre zur Ausführung erhalten?
[code]public class Test {
public static Object object = new Object();
public static void main(String[] args) {
Thread1 thread1 = new Thread1();
Thread2 thread2 = new Thread2();
thread1.start();
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
thread2.start();
}
static class Thread1 extends Thread{
@Override
public void run() {
synchronized (object) {
try {
object.wait();
} catch (InterruptedException e) {
}
System.out.println("线程"+Thread.currentThread().getName()+"获取到了锁");
}
}
}
static class Thread2 extends Thread{
@Override
public void run() {
synchronized (object) {
object.notify();
System.out.println("线程"+Thread.currentThread().getName()+"调用了object.notify()");
}
System.out.println("线程"+Thread.currentThread().getName()+"释放了锁");
}
}
}Bedingung
Bedingung erschien nur in Java 1.5. Sie wird verwendet, um die herkömmlichen Funktionen „wait()“ und „notify()“ zu ersetzen. Implementiert die Zusammenarbeit zwischen Threads. Im Vergleich zur Verwendung von wait () und notify () von Object ist es sicherer und effizienter, die Zusammenarbeit () und signal () von Condition1 zu verwenden, um eine Zusammenarbeit zwischen Threads zu erreichen. Daher wird im Allgemeinen empfohlen, Condition zu verwenden.Condition ist eine Schnittstelle, und die grundlegenden Methoden sind waiting() und signal().
Condition hängt von der Lock-Schnittstelle ab, und der Basiscode zum Generieren einer Bedingung ist lock.newCondition()
Die Methoden „await()“ und „signal()“ von Calling Condition müssen innerhalb des Sperrschutzes liegen, was bedeutet, dass sie zwischen lock.lock() und lock.unlock verwendet werden müssen
Conditon中的await()对应Object的wait()； Condition中的signal()对应Object的notify()； Condition中的signalAll()对应Object的notifyAll()。
[code]public class Test {
private int queueSize = 10;
private PriorityQueue<Integer> queue = new PriorityQueue<Integer>(queueSize);
public static void main(String[] args) {
Test test = new Test();
Producer producer = test.new Producer();
Consumer consumer = test.new Consumer();
producer.start();
consumer.start();
}
class Consumer extends Thread{
@Override
public void run() {
consume();
}
private void consume() {
while(true){
synchronized (queue) {
while(queue.size() == 0){
try {
System.out.println("队列空，等待数据");
queue.wait();
} catch (InterruptedException e) {
e.printStackTrace();
queue.notify();
}
}
queue.poll(); //每次移走队首元素
queue.notify();
System.out.println("从队列取走一个元素，队列剩余"+queue.size()+"个元素");
}
}
}
}
class Producer extends Thread{
@Override
public void run() {
produce();
}
private void produce() {
while(true){
synchronized (queue) {
while(queue.size() == queueSize){
try {
System.out.println("队列满，等待有空余空间");
queue.wait();
} catch (InterruptedException e) {
e.printStackTrace();
queue.notify();
}
}
queue.offer(1); //每次插入一个元素
queue.notify();
System.out.println("向队列取中插入一个元素，队列剩余空间："+(queueSize-queue.size()));
}
}
}
}
}[code]public class Test {
private int queueSize = 10;
private PriorityQueue<Integer> queue = new PriorityQueue<Integer>(queueSize);
private Lock lock = new ReentrantLock();
private Condition notFull = lock.newCondition();
private Condition notEmpty = lock.newCondition();
public static void main(String[] args) {
Test test = new Test();
Producer producer = test.new Producer();
Consumer consumer = test.new Consumer();
producer.start();
consumer.start();
}
class Consumer extends Thread{
@Override
public void run() {
consume();
}
private void consume() {
while(true){
lock.lock();
try {
while(queue.size() == 0){
try {
System.out.println("队列空，等待数据");
notEmpty.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
queue.poll(); //每次移走队首元素
notFull.signal();
System.out.println("从队列取走一个元素，队列剩余"+queue.size()+"个元素");
} finally{
lock.unlock();
}
}
}
}
class Producer extends Thread{
@Override
public void run() {
produce();
}
private void produce() {
while(true){
lock.lock();
try {
while(queue.size() == queueSize){
try {
System.out.println("队列满，等待有空余空间");
notFull.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
queue.offer(1); //每次插入一个元素
notEmpty.signal();
System.out.println("向队列取中插入一个元素，队列剩余空间："+(queueSize-queue.size()));
} finally{
lock.unlock();
}
}
}
}
}
以上就是java-并发-线程间协作的两种方式：wait、notify、notifyAll和Condition的内容，更多相关内容请关注PHP中文网（www.php.cn）！
相关文章：