2. 程式人生 > >java多執行緒基礎總結【四】虛假喚醒

java多執行緒基礎總結【四】虛假喚醒

阿新 • • 發佈：2019-02-11
我們先來看一組例子
package com.buerc.thread;

public class TesProducerAndConsumer {
	public static void main(String[] args) {
		Clerk clerk=new Clerk();
		
		Producer producer=new Producer(clerk);
		Consumer consumer=new Consumer(clerk);
		
		new Thread(producer,"生產者A1").start();
		new Thread(consumer,"消費者B1").start();
	}
}

class Clerk{//店員類
	private static final int TOTAL=1;//數字取1是為了放大問題
	private int num=0;
	
	public synchronized void get() {//店員買貨
		if(num>=TOTAL) {
			System.out.println("庫存已滿，無法進貨");
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}else {
			System.out.println(Thread.currentThread().getName()+" : "+ (num++));
			this.notifyAll();
		}
	}
	
	public synchronized void sale() {//店員賣貨
		if(num<=0) {
			System.out.println("庫存已空，無法賣貨");
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}else {
			System.out.println(Thread.currentThread().getName()+" : "+(num--));
			this.notifyAll();
		}
	}
}

class Producer implements Runnable{
	private Clerk clerk;
	
	public Producer(Clerk clerk) {
		this.clerk=clerk;
	}
	
	@Override
	public void run() {
		for (int i = 0; i<20; i++) {
			try {
				Thread.sleep(200);//放大問題
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			clerk.get();
		}
	}
}

class Consumer implements Runnable{
	private Clerk clerk;
	
	public Consumer(Clerk clerk) {
		this.clerk=clerk;
	}
	
	@Override
	public void run() {
		for (int i = 0; i<20; i++) {
			clerk.sale();
		}
	}
}
這樣看起來似乎很合理。一個生產者生產，一個消費者消費，但是執行起來卻是控制檯沒停。而我們這裡是for20次迴圈，按理來說程式最終會終止，可情況恰恰相反。問題產生的根源是，由於生產者現象睡眠了200毫秒，因而可能產生的情況是最後消費者執行緒迴圈走完了然後就真的結束了，而生產者執行緒由於wait沒有執行緒來喚醒，所以最終導致一直等待，因而程式不會結束，控制檯就不終止。解決方法：
package com.buerc.thread;

public class TesProducerAndConsumer {
	public static void main(String[] args) {
		Clerk clerk=new Clerk();
		
		Producer producer=new Producer(clerk);
		Consumer consumer=new Consumer(clerk);
		
		new Thread(producer,"生產者A1").start();
		new Thread(consumer,"消費者B1").start();
	}
}

class Clerk{//店員類
	private static final int TOTAL=1;//數字取1是為了放大問題
	private int num=0;
	
	public synchronized void get() {//店員買貨
		if(num>=TOTAL) {
			System.out.println("庫存已滿，無法進貨");
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println(Thread.currentThread().getName()+" : "+ (num++));
		this.notifyAll();
	}
	
	public synchronized void sale() {//店員賣貨
		if(num<=0) {
			System.out.println("庫存已空，無法賣貨");
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println(Thread.currentThread().getName()+" : "+(num--));
		this.notifyAll();
		
	}
}

class Producer implements Runnable{
	private Clerk clerk;
	
	public Producer(Clerk clerk) {
		this.clerk=clerk;
	}
	
	@Override
	public void run() {
		for (int i = 0; i<20; i++) {
			try {
				Thread.sleep(200);//放大問題
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			clerk.get();
		}
	}
}

class Consumer implements Runnable{
	private Clerk clerk;
	
	public Consumer(Clerk clerk) {
		this.clerk=clerk;
	}
	
	@Override
	public void run() {
		for (int i = 0; i<20; i++) {
			clerk.sale();
		}
	}
}

這裡把同步方法的else去掉了，那麼無論最終哪個執行緒先走完，都會執行wait後面的方法，即它在結束前會喚醒等待的執行緒，因而這個執行緒最終也會完整的執行完，最後程式終止。這種方法的確解決了程式無法終止的問題，但是我們來看看，當我們多加一對消費者執行緒和生產者執行緒時。

package com.buerc.thread;

public class TesProducerAndConsumer {
	public static void main(String[] args) {
		Clerk clerk=new Clerk();
		
		Producer producer=new Producer(clerk);
		Consumer consumer=new Consumer(clerk);
		Producer producer2=new Producer(clerk);
		Consumer consumer2=new Consumer(clerk);
		
		new Thread(producer,"生產者A1").start();
		new Thread(consumer,"消費者B1").start();
		new Thread(producer2,"生產者A2").start();
		new Thread(consumer2,"消費者B2").start();
	}
}

class Clerk{//店員類
	private static final int TOTAL=1;//數字取1是為了放大問題
	private int num=0;
	
	public synchronized void get() {//店員買貨
		if(num>=TOTAL) {
			System.out.println("庫存已滿，無法進貨");
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println(Thread.currentThread().getName()+" : "+ (num++));
		this.notifyAll();
	}
	
	public synchronized void sale() {//店員賣貨
		if(num<=0) {
			System.out.println("庫存已空，無法賣貨");
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println(Thread.currentThread().getName()+" : "+(num--));
		this.notifyAll();
		
	}
}

class Producer implements Runnable{
	private Clerk clerk;
	
	public Producer(Clerk clerk) {
		this.clerk=clerk;
	}
	
	@Override
	public void run() {
		for (int i = 0; i<20; i++) {
			try {
				Thread.sleep(200);//放大問題
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			clerk.get();
		}
	}
}

class Consumer implements Runnable{
	private Clerk clerk;
	
	public Consumer(Clerk clerk) {
		this.clerk=clerk;
	}
	
	@Override
	public void run() {
		for (int i = 0; i<20; i++) {
			clerk.sale();
		}
	}
}
這種情況出現了產品數為負的情況，肯定不合適。這就是虛假喚醒，因為有可能num==0，然後兩個消費者執行緒都wait,此時生產者執行num++後，在喚醒卻是喚醒了所有等待的執行緒，此時這兩個消費者執行緒搶佔資源後立馬執行wait之後的操作，即num--就會出現產品為負的情況。為了避免這種情況我們應該讓wait（）在while迴圈中。（API上關於虛假喚醒的解決方式）
package com.buerc.thread;

public class TesProducerAndConsumer {
	public static void main(String[] args) {
		Clerk clerk=new Clerk();
		
		Producer producer=new Producer(clerk);
		Consumer consumer=new Consumer(clerk);
		Producer producer2=new Producer(clerk);
		Consumer consumer2=new Consumer(clerk);
		
		new Thread(producer,"生產者A1").start();
		new Thread(consumer,"消費者B1").start();
		new Thread(producer2,"生產者A2").start();
		new Thread(consumer2,"消費者B2").start();
	}
}

class Clerk{//店員類
	private static final int TOTAL=1;//數字取1是為了放大問題
	private int num=0;
	
	public synchronized void get() {//店員買貨
		while(num>=TOTAL) {
			System.out.println("庫存已滿，無法進貨");
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println(Thread.currentThread().getName()+" : "+ (num++));
		this.notifyAll();
	}
	
	public synchronized void sale() {//店員賣貨
		while(num<=0) {
			System.out.println("庫存已空，無法賣貨");
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println(Thread.currentThread().getName()+" : "+(num--));
		this.notifyAll();
		
	}
}

class Producer implements Runnable{
	private Clerk clerk;
	
	public Producer(Clerk clerk) {
		this.clerk=clerk;
	}
	
	@Override
	public void run() {
		for (int i = 0; i<20; i++) {
			try {
				Thread.sleep(200);//放大問題
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			clerk.get();
		}
	}
}

class Consumer implements Runnable{
	private Clerk clerk;
	
	public Consumer(Clerk clerk) {
		this.clerk=clerk;
	}
	
	@Override
	public void run() {
		for (int i = 0; i<20; i++) {
			clerk.sale();
		}
	}
}

相關推薦

java多執行緒基礎總結【四】虛假喚醒

我們先來看一組例子package com.buerc.thread; public class TesProducerAndConsumer { public static void main(String[] args) { Clerk clerk=new Cler

【Java多執行緒併發總結】Thread類的常用方法(join、yield等)---執行緒的基礎操作篇

 啟動(start)   最基本的操作，呼叫Runnable中的run方法，無返回值。 new Thread(new Test()).start(); 休眠(sleep)  使當前執行緒休眠一段時間，預設為毫秒級，最高可以精確到納秒，呼叫的方法為slee

Java多執行緒程式設計總結筆記——02多執行緒基礎知識

讀解Thread類API 構造方法摘要 Thread(Runnable target) 分配新的 Thread 物件。 Thread(String name) 分配新的 Thread 物件。 方法摘要 static Thread cur

最全java多執行緒學習總結1--執行緒基礎

  《java 核心技術》這本書真的不錯，知識點很全面，翻譯質量也還不錯，本系列博文是對該書中併發章節的一個總結。 什麼是執行緒   官方解釋：執行緒是作業系統能夠進行運算排程的最小單位，包含於程序之中，是程序中的實際運作單位。也就是說執行緒是程式碼執行的載體，我們所編寫的程式碼都是線上程上跑的，以一個最簡單

【對線面試官】Java多執行緒基礎

![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/c3ad3d76a4d04a9680160f319c889287~tplv-k3u1fbpfcp-zoom-1.image) ![](https://p3-juejin.byteimg.com/tos

Java多執行緒-基礎及實現

1. 什麼是執行緒 執行緒是程序內的執行單元     某個程序當中都有若干個執行緒。 執行緒是程序內的執行單元。 使用執行緒的原因是，程序的切換是非常重量級

java 多執行緒基礎2

      多執行緒(加入執行緒join) thread.join(); 被.join()的執行緒優先執行 多執行緒(執行緒優先順序Priority) Thread.setPriority(1-10)執行緒預設優先順序是5。執行緒優先順序的範圍是

java多執行緒 基礎

引入  1.什麼是執行緒           執行緒是程式執行的一條路徑, 一個程序中可以包含多條執行緒        

【JAVA多執行緒問題之死鎖】

  一、死鎖是什麼？ 舉個例子：兩個人一起吃飯，每個人都拿了一隻筷子，雙方都在等待對方將筷子讓給自己，結果兩個人都吃不了飯。這種情況和計算機中的死鎖情況很相似。 假設有兩個執行緒，互相等待對方釋放佔有的鎖，但是釋放鎖的條件又不可能形成，這時候死鎖就形成了。 還是買票的問題，有的時候時會發生死

java多執行緒--練習題總結

目錄   練題1:編寫程式實現,子執行緒迴圈3次,接著主執行緒迴圈5次,接著再子執行緒迴圈3次,主執行緒迴圈5次,如此反覆,迴圈3次. 練習題2:設計四個執行緒,其中兩個執行緒每次對變數i加1,另外兩個執行緒每次對i減1. 練習題3:自己編寫程式碼,實現生產者-消費者模

java多執行緒快速入門（四）

通過匿名內部類的方法建立多執行緒 package com.cppdy; //通過匿名內部類的方法建立多執行緒 public class ThreadDemo2 { public static void main(String[] args) { new Thread(ne

Java——多執行緒基本使用（四） 執行緒組和執行緒池的使用，工廠設計模式的使用

1.執行緒組的概述和使用 Java中使用ThreadGroup來表示執行緒組，它可以對一批執行緒進行分類管理，Java允許程式直接對執行緒組進行控制。            &n

Java多執行緒-基礎篇（一）

多執行緒---基礎篇，本文主要針對多執行緒的基礎進行復習，內容包括執行緒的理解，建立方式，Thread類函式理解； 1、執行緒的理解：OS系統角度：每個執行的程式都會被作業系統建立對應的程序（包括分配的資源、PCB等），程序是作業系統分配資源的基本單位（理解：程式執行需要空間，作業系統建立對應程序時

#Java多執行緒知識點總結wait、notify、notifyAll

Java多執行緒 設計一個典型的場景，來闡述wait()、notify()、notifyAll()，生產消費者。 有生產者、消費者、緩衝佇列（size=10）。 生產者不停地向緩衝佇列裡放資料，一旦佇列滿了，則wait()，並notify()消費者進行處理。 消費者不停地從緩衝佇列裡

Java多執行緒基礎之手撕生產者和消費者模式

問題描述 資料結構： 生產者/消費者 快取區(共享資源) 規則： 生產/消費者同時操作快取區。 當快取區為空的時候，消費者不能消費，即消費者阻塞。 當快取區為滿的時候，生產者不能生產，即生產者阻

Java多執行緒學習筆記（四）

1、原子性：操作不能被打斷，要麼成功要麼失敗。i++ 不是原子操作。 2、可見性：一個執行緒修改了資料，其他執行緒立刻可見。 3、順序性： 4、volatile 保證程式的可見性，和順序性。不能保證對複合操作（如i++)的原子性。 javap -v xxx.class

面試系列-40個Java多執行緒問題總結

前言 這篇文章主要是對多執行緒的問題進行總結的，因此羅列了40個多執行緒的問題。 這些多執行緒的問題，有些來源於各大網站、有些來源於自己的思考。可能有些問題網上有、可能有些問題對應的答案也有、也可能有些各位網友也都看過，但是本文寫作的重心就是 所有的問題都會按照自己的理解

java多執行緒基礎

本文就java多執行緒的基本使用方法、執行緒同步、執行緒狀態、執行緒函式等記錄一些總結。         程序：程序是資源分配的最小單位。每個程序都有獨立的程式碼和資料空間，程序間切換會有較大的開銷，一個程序往往包含多個執行緒。         執行緒：執行緒是CPU排程

java多執行緒知識總結

程序：一個程序包括由作業系統分配的記憶體空間，包含一個或多個執行緒。一個執行緒不能獨立的存在，它必須是程序的一部分。一個程序一直執行，直到所有的非守護執行緒都結束執行後才能結束。 多執行緒能滿足程式設計師編寫高效率的程式來達到充分利用 CPU 的目的。 詳細解釋： 程式：為了完成特定任務

Java多執行緒基礎之停止執行緒

JAVA中有3種終止正在執行的執行緒： 使用退出標誌，使執行緒正常的退出，也就是run方法執行完成後執行緒終止。 使用stop方式強行終止執行緒，但是不推薦使用這種方式，因為stop和suspend及resume一樣，都是作廢過期的方法，使用它們可能產生不可預料的後果。 使用i