1. 生產者與消費者
1.1 程序基本實現（問題引出）
生產者與消費者是線程操作的經典案例繁成，即：生產者不斷生產，消費者不斷取走生產者生產的產品面睛。接下來尊搬，我們以買早餐為例講解如何實現生產者與消費者。
假設亲茅，一個早餐店只賣下面兩種套餐：
- 煎餅果子狗准，無糖豆?jié){
- 鍋盔辣子莢膜茵肃，豆腐腦
接下來验残，用程序實現這個過程：
//源碼：
//早餐
public class Breakfast_201811011939 {
private String food;
private String drinking;
public Breakfast_201811011939(){}
public Breakfast_201811011939(String f, String d){
this.food = f;
this.drinking = d;
}
public String getFood() {
return food;
}
public void setFood(String food) {
this.food = food;
}
public String getDrinking() {
return drinking;
}
public void setDrinking(String drinking) {
this.drinking = drinking;
}
}
//早餐店
public class Restaurant_201811011951 implements Runnable {
private Breakfast_201811011939 breakfast;
public Restaurant_201811011951(Breakfast_201811011939 b){
this.breakfast = b;
}
@Override
public void run() {
boolean isFirstSetMeal = false;
for (int i = 0; i < 25; i++) {
if(isFirstSetMeal){
this.breakfast.setFood("煎餅果子");
try {
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
this.breakfast.setDrinking("無糖豆?jié){");
isFirstSetMeal = false;
}else{
this.breakfast.setFood("鍋盔辣子莢膜");
try {
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
this.breakfast.setDrinking("豆腐腦");
isFirstSetMeal = true;
}
}
}
}
//顧客
public class Consumer_201811011958 implements Runnable {
private Breakfast_201811011939 breakfast;
public Consumer_201811011958(Breakfast_201811011939 b){
this.breakfast = b;
}
@Override
public void run() {
for (int i = 0; i < 25; i++) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("套餐： " + breakfast.getFood() + " " + breakfast.getDrinking() + " " + (i+1));
}
}
}
//Main
public class Main_201811012005 {
public static void main(String[] args) {
Breakfast_201811011939 breakfast = new Breakfast_201811011939();
Restaurant_201811011951 restaurant = new Restaurant_201811011951(breakfast);
Consumer_201811011958 consumer = new Consumer_201811011958(breakfast);
new Thread(restaurant).start();
new Thread(consumer).start();
}
}
//執(zhí)行結果：
套餐： 煎餅果子 豆腐腦 1
套餐： 鍋盔辣子莢膜 無糖豆?jié){ 2
套餐： 煎餅果子 豆腐腦 3
套餐： 鍋盔辣子莢膜 無糖豆?jié){ 4
套餐： 煎餅果子 豆腐腦 5
套餐： 鍋盔辣子莢膜 無糖豆?jié){ 6
套餐： 煎餅果子 豆腐腦 7
套餐： 鍋盔辣子莢膜 無糖豆?jié){ 8
套餐： 煎餅果子 豆腐腦 9
套餐： 鍋盔辣子莢膜 無糖豆?jié){ 10
套餐： 煎餅果子 豆腐腦 11
套餐： 鍋盔辣子莢膜 無糖豆?jié){ 12
套餐： 煎餅果子 豆腐腦 13
套餐： 鍋盔辣子莢膜 無糖豆?jié){ 14
套餐： 煎餅果子 豆腐腦 15
套餐： 鍋盔辣子莢膜 無糖豆?jié){ 16
套餐： 煎餅果子 豆腐腦 17
套餐： 鍋盔辣子莢膜 無糖豆?jié){ 18
套餐： 煎餅果子 豆腐腦 19
套餐： 鍋盔辣子莢膜 無糖豆?jié){ 20
套餐： 煎餅果子 豆腐腦 21
套餐： 鍋盔辣子莢膜 無糖豆?jié){ 22
套餐： 煎餅果子 豆腐腦 23
套餐： 鍋盔辣子莢膜 無糖豆?jié){ 24
套餐： 鍋盔辣子莢膜 無糖豆?jié){ 25
由執(zhí)行結果可知鸟召，上面的程序有兩個問題：
- 信息錯亂
Restaurant 線程剛添加完 Food 信息還沒有來得及添加 Drinking 信息，Consumer 線程就過來取 Breakfast 了，此時信息就會錯亂种冬。 - 連續(xù)存儲
Restaurant 添加了 N 次 Breakfast 信息之后娱两，Consumer 線程才過來取 Breakfast 或者 Consumer 線程過來取了 N 次信息之后金吗，Restaurant 才往 Breakfast 里面添加新的信息摇庙，此時就會造成連續(xù)存取的問題异袄。
1.2 解決信息錯亂問題——添加同步
信息錯亂明顯是因為資源共享未同步造成的烤蜕，所以解決方法當然是同步迹冤。
接下來泡徙，根據分析結果對上述代碼進行修改：
//源碼：
//早餐
public class Breakfast_201811012009 {
private String food;
private String drinking;
public Breakfast_201811012009(){}
public Breakfast_201811012009(String f, String d){
this.food = f;
this.drinking = d;
}
public synchronized void setBreakfast(String f, String d) {
setFood(f);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
setDrinking(d);
}
public synchronized void getBreakfast(){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("套餐： " + getFood() + " " + getDrinking());
}
public String getFood() {
return food;
}
public void setFood(String food) {
this.food = food;
}
public String getDrinking() {
return drinking;
}
public void setDrinking(String drinking) {
this.drinking = drinking;
}
}
//早餐店
public class Restaurant_201811012032 implements Runnable {
private Breakfast_201811012009 breakfast;
public Restaurant_201811012032(Breakfast_201811012009 b){
this.breakfast = b;
}
@Override
public void run() {
boolean isFirstSetMeal = false;
for (int i = 0; i < 25; i++) {
if(isFirstSetMeal){
this.breakfast.setBreakfast("煎餅果子", "無糖豆?jié){" + " " + (i+1));
isFirstSetMeal = false;
}else{
this.breakfast.setBreakfast("鍋盔辣子莢膜", "豆腐腦" + " " + (i+1));
isFirstSetMeal = true;
}
}
}
}
//顧客
public class Consumer_201811012018 implements Runnable {
private Breakfast_201811012009 breakfast;
public Consumer_201811012018(Breakfast_201811012009 b){
this.breakfast = b;
}
@Override
public void run() {
for (int i = 0; i < 25; i++) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.breakfast.getBreakfast();
}
}
}
//Main
public class Main_201811012005 {
public static void main(String[] args) {
Breakfast_201811012009 breakfast = new Breakfast_201811012009();
Consumer_201811012018 restaurant = new Consumer_201811012018(breakfast);
Restaurant_201811012032 consumer = new Restaurant_201811012032(breakfast);
new Thread(restaurant).start();
new Thread(consumer).start();
}
}
//執(zhí)行結果：
套餐： 鍋盔辣子莢膜 豆腐腦 1
套餐： 煎餅果子 無糖豆?jié){ 2
套餐： 鍋盔辣子莢膜 豆腐腦 3
套餐： 煎餅果子 無糖豆?jié){ 4
套餐： 鍋盔辣子莢膜 豆腐腦 5
套餐： 煎餅果子 無糖豆?jié){ 6
套餐： 煎餅果子 無糖豆?jié){ 8
套餐： 鍋盔辣子莢膜 豆腐腦 9
套餐： 煎餅果子 無糖豆?jié){ 10
套餐： 鍋盔辣子莢膜 豆腐腦 11
套餐： 煎餅果子 無糖豆?jié){ 12
套餐： 煎餅果子 無糖豆?jié){ 16
套餐： 鍋盔辣子莢膜 豆腐腦 17
套餐： 煎餅果子 無糖豆?jié){ 18
套餐： 鍋盔辣子莢膜 豆腐腦 19
套餐： 煎餅果子 無糖豆?jié){ 20
套餐： 鍋盔辣子莢膜 豆腐腦 21
套餐： 煎餅果子 無糖豆?jié){ 22
套餐： 鍋盔辣子莢膜 豆腐腦 23
套餐： 煎餅果子 無糖豆?jié){ 24
套餐： 鍋盔辣子莢膜 豆腐腦 25
套餐： 鍋盔辣子莢膜 豆腐腦 25
套餐： 鍋盔辣子莢膜 豆腐腦 25
套餐： 鍋盔辣子莢膜 豆腐腦 25
套餐： 鍋盔辣子莢膜 豆腐腦 25
由執(zhí)行結果可知莉兰，經過同步處理之后礁竞，信息錯亂的問題解決了，但連續(xù)存取的問題還在捶朵。
之所以在執(zhí)行結果中會漏掉某些數字，如：7品腹，13红碑，14，15镣典，是因為 Restaurant 線程添加完 Breakfast 信息唾琼，Consumer 線程沒有及時取走，于是信息展示的時候赶舆，漏掉了這些數字祭饭；
之所以在執(zhí)行結果中會出現連續(xù)幾次數字一樣的情況，如：25 連續(xù)出現了 5 次九串，是因為 Restaurant 線程已經執(zhí)行完畢寺鸥，即：此時 Breakfast 信息已經不更改，而 Consumer 線程還沒有執(zhí)行完畢烤低。其實歸根結底還是因為 Restaurant 線程和 Consumer 線程沒有交替操作 Breakfast 對象笆载。
那如何才能使 Restaurant 線程和 Consumer 線程交替操作 Breakfast 對象呢凉驻？——加入等待和喚醒。
1.3 解決連續(xù)存取問題——添加等待與喚醒
在 Object 類中定義了線程等待（wait）與喚醒（notify）的方法：
//Wait 線程等待
/**
* Causes the current thread to wait until another thread invokes the
* {@link java.lang.Object#notify()} method or the
* {@link java.lang.Object#notifyAll()} method for this object.
* …
*/
public final void wait() throws InterruptedException {
wait(0);
}
//Notify 喚醒第一個等待的線程
/**
* Wakes up a single thread that is waiting on this object's
* monitor.
* …
*/
public final native void notify();
那等待與喚醒如何添加呢闯第？
可以通過一個標志位來控制缀拭，假設標志位是一個 Boolean 變量，當標志位內容為 true 時咙好，表示可以 Restaurant 線程可以添加 Breakfast 信息褐荷，此時如果 CPU 調度了 Consumer 線程則等待，反之亦然层宫。
接下來其监，根據分析結果對上述代碼進行修改：
//源碼：
//早餐
public class Breakfast_201811012300 {
private String food;
private String drinking;
private boolean canCookBreakfast = true;
public Breakfast_201811012300(){}
public Breakfast_201811012300(String f, String d){
this.food = f;
this.drinking = d;
}
public synchronized void setBreakfast(String f, String d) {
if(!canCookBreakfast){
try {
super.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
setFood(f);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
setDrinking(d);
canCookBreakfast = false;
super.notify();
}
public synchronized void getBreakfast(){
if(canCookBreakfast){
try {
super.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("套餐： " + getFood() + " " + getDrinking());
canCookBreakfast = true;
super.notify();
}
public String getFood() {
return food;
}
public void setFood(String food) {
this.food = food;
}
public String getDrinking() {
return drinking;
}
public void setDrinking(String drinking) {
this.drinking = drinking;
}
}
//早餐店
public class Restaurant_201811012300 implements Runnable {
private Breakfast_201811012300 breakfast;
public Restaurant_201811012300(Breakfast_201811012300 b){
this.breakfast = b;
}
@Override
public void run() {
boolean isFirstSetMeal = false;
for (int i = 0; i < 25; i++) {
if(isFirstSetMeal){
this.breakfast.setBreakfast("煎餅果子", "無糖豆?jié){" + " " + (i+1));
isFirstSetMeal = false;
}else{
this.breakfast.setBreakfast("鍋盔辣子莢膜", "豆腐腦" + " " + (i+1));
isFirstSetMeal = true;
}
}
}
}
//顧客
public class Consumer_201811012300 implements Runnable {
private Breakfast_201811012300 breakfast;
public Consumer_201811012300(Breakfast_201811012300 b){
this.breakfast = b;
}
@Override
public void run() {
for (int i = 0; i < 25; i++) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.breakfast.getBreakfast();
}
}
}
//Main
public class Main_201811012005 {
public static void main(String[] args) {
Breakfast_201811012300 breakfast = new Breakfast_201811012300();
Consumer_201811012300 restaurant = new Consumer_201811012300(breakfast);
Restaurant_201811012300 consumer = new Restaurant_201811012300(breakfast);
new Thread(restaurant).start();
new Thread(consumer).start();
}
}
//執(zhí)行結果：
套餐： 鍋盔辣子莢膜 豆腐腦 1
套餐： 煎餅果子 無糖豆?jié){ 2
套餐： 鍋盔辣子莢膜 豆腐腦 3
套餐： 煎餅果子 無糖豆?jié){ 4
套餐： 鍋盔辣子莢膜 豆腐腦 5
套餐： 煎餅果子 無糖豆?jié){ 6
套餐： 鍋盔辣子莢膜 豆腐腦 7
套餐： 煎餅果子 無糖豆?jié){ 8
套餐： 鍋盔辣子莢膜 豆腐腦 9
套餐： 煎餅果子 無糖豆?jié){ 10
套餐： 鍋盔辣子莢膜 豆腐腦 11
套餐： 煎餅果子 無糖豆?jié){ 12
套餐： 鍋盔辣子莢膜 豆腐腦 13
套餐： 煎餅果子 無糖豆?jié){ 14
套餐： 鍋盔辣子莢膜 豆腐腦 15
套餐： 煎餅果子 無糖豆?jié){ 16
套餐： 鍋盔辣子莢膜 豆腐腦 17
套餐： 煎餅果子 無糖豆?jié){ 18
套餐： 鍋盔辣子莢膜 豆腐腦 19
套餐： 煎餅果子 無糖豆?jié){ 20
套餐： 鍋盔辣子莢膜 豆腐腦 21
套餐： 煎餅果子 無糖豆?jié){ 22
套餐： 鍋盔辣子莢膜 豆腐腦 23
套餐： 煎餅果子 無糖豆?jié){ 24
套餐： 鍋盔辣子莢膜 豆腐腦 25
由上面的執(zhí)行結果可知，加入等待與喚醒之后贮庞，連續(xù)存取的問題得到解決究西，即：Restaurant 線程添加完 Breakfast 信息之后，只有當 Consumer 線程取走 Breakfast 之后才添加新的 Breakfast 信息。當 Restaurant 線程添加完 Breakfast 信息之后商膊，如果 CPU 又調度了一次 Restaurant 線程，這個時候吝镣，Restaurant 線程就會等待（wait）末贾，直至被 Notify（切換至 Consumer 線程辉川，Consumer 線程取走 Breakfast 信息之后，通知（Notify）第一個等待的線程屿愚，此時 Restaurant 線程才被喚醒），當 CPU 重復調用 Consumer 線程時娱据，處理的邏輯是一樣吸耿，因此不在此贅述。
參考文檔
1）《Java 開發(fā)實戰(zhàn)經典》
2）《Thinking in Java》
3）Android Developer Document
4）Java Tutorials
