2. 程式人生 > >Java多執行緒實現非同步呼叫的方法

Java多執行緒實現非同步呼叫的方法

阿新 • • 發佈：2019-02-17

一個呼叫者在呼叫耗時操作,不能立即返回資料時,先返回一個提貨單.然後在過一斷時間後憑提貨單來獲取真正的資料.
去蛋糕店買蛋糕，不需要等蛋糕做出來（假設現做要很長時間），只需要領個提貨單就可以了（去幹別的事情），等到蛋糕做好了，再拿提貨單取蛋糕就可以了。

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

public class Main { 

public static

void main(String[] args) { 

System.out.println("main BEGIN"); 

Host host = new Host(); 

Data data1 = host.request(10, 'A'); 

Data data2 = host.request(20, 'B'); 

Data data3 = host.request(30, 'C'); 

System.out.println("main otherJob BEGIN"); 

try { 

Thread.sleep(

200); 

} catch (InterruptedException e) { 

} 

System.out.println("main otherJob END"); 

System.out.println("data1 = " + data1.getContent()); 

System.out.println("data2 = " + data2.getContent()); 

System.out.println("data3 = " + data3.getContent()); 

System.out.println(

"main END"); 

} 

}

 這裡的main類就相當於“顧客”，host就相當於“蛋糕店”，顧客向“蛋糕店”定蛋糕就相當於“發請求request”，返回的資料data是FutureData的例項，就相當於提貨單，而不是真正的“蛋糕”。在過一段時間後（sleep一段時間後），呼叫data1.getContent()，也就是拿提貨單獲取執行結果。

下面來看一下，顧客定蛋糕後，蛋糕店做了什麼：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

public class Host { 

public Data request(final int count, final char c) { 

System.out.println("request(" + count + ", " + c + ") BEGIN"); 

// (1) 建立FutureData的實體 

final FutureData future = new FutureData(); 

// (2) 為了建立RealData的實體，啟動新的執行緒 

new Thread() {                    

public void run() { 

//在匿名內部類中使用count、future、c。           

RealData realdata = new RealData(count, c); 

future.setRealData(realdata); 

}                        

}.start();                      

System.out.println("request(" + count + ", " + c + ") END"); 

// (3) 取回FutureData實體，作為傳回值 

return future; 

} 

}

  host("蛋糕店")在接到請求後，先生成了“提貨單”FutureData的例項future，然後命令“蛋糕師傅”RealData去做蛋糕，realdata相當於起個執行緒去做蛋糕了。然後host返回給顧客的僅僅是“提貨單”future，而不是蛋糕。當蛋糕做好後，蛋糕師傅才能給對應的“提貨單”蛋糕，也就是future.setRealData(realdata)。

下面來看看蛋糕師傅是怎麼做蛋糕的：

建立一個字串，包含count個c字元，為了表現出犯法需要花費一些時間，使用了sleep。

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

public class RealData implements Data { 

private final String content; 

public RealData(int count, char c) { 

System.out.println("making RealData(" + count + ", " + c + ") BEGIN"); 

char[] buffer = new char[count]; 

for (int i = 0; i < count; i++) { 

buffer[i] = c; 

try { 

Thread.sleep(1000); 

} catch (InterruptedException e) { 

} 

} 

System.out.println("making RealData(" + count + ", " + c + ") END"); 

this.content = new String(buffer); 

} 

public String getContent() { 

return content; 

} 

}

     現在來看看“提貨單”future是怎麼與蛋糕"content"對應的:

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

public class FutureData implements Data { 

private RealData realdata = null; 

private boolean ready = false; 

public synchronized void setRealData(RealData realdata) { 

if (ready) {             

return;   // 防止setRealData被呼叫兩次以上。

} 

this.realdata = realdata; 

this.ready = true; 

notifyAll(); 

} 

public synchronized String getContent() { 

while (!ready) { 

try { 

wait(); 

} catch (InterruptedException e) { 

} 

} 

return realdata.getContent(); 

} 

}

   顧客做完自己的事情後，會拿著自己的“提貨單”來取蛋糕：

?

1

System.out.println("data1 = " + data1.getContent());

這時候如果蛋糕沒做好，就只好等了：

?

1

2

3

4

5

6

7

while (!ready) { 

try { 

wait(); 

} catch (InterruptedException e) { 

} 

//等做好後才能取到  

return realdata.getContent();

    程式分析

    對於每個請求，host都會生成一個執行緒，這個執行緒負責生成顧客需要的“蛋糕”。在等待一段時間以後，如果蛋糕還沒有做好，顧客還必須等待。直到“蛋糕被做好”，也就是future.setRealData(realdata); 執行以後，顧客才能拿走蛋糕。

   每個執行緒只是專門負責製作特定顧客所需要的“蛋糕”。也就是顧客A對應著蛋糕師傅A，顧客B對應著蛋糕師傅B。即使顧客B的蛋糕被先做好了，顧客A也只能等待蛋糕師傅A把蛋糕做好。換句話說，顧客之間沒有競爭關係。

   類FutureData的兩個方法被設定為synchronized，實際上蛋糕師傅A與顧客A之間的互斥關係，也就是顧客A必須等待蛋糕師傅A把蛋糕做好後，才能拿走，而與蛋糕師傅B是否做好了蛋糕沒有關係。

本文內容就到此全部結束了，程式碼簡單吧，希望對大家學習Java多執行緒實現非同步呼叫有所幫助，謝謝。

相關推薦

Java多執行緒實現非同步呼叫的方法

一個呼叫者在呼叫耗時操作,不能立即返回資料時,先返回一個提貨單.然後在過一斷時間後憑提貨單來獲取真正的資料. 去蛋糕店買蛋糕，不需要等蛋糕做出來（假設現做要很長時間），只需要領個提貨單就可以了（去幹別的事情），等到蛋糕做好了，再拿提貨單取蛋糕就可以了。 ? 1

Java多執行緒實現非同步呼叫

在JAVA平臺,實現非同步呼叫的角色有如下三個角色:呼叫者 提貨單   真實資料 一個呼叫者在呼叫耗時操作,不能立即返回資料時,先返回一個提貨單.然後在過一斷時間後憑提貨單來獲取真正的資料. 去蛋糕店買蛋糕，不需要等蛋糕做出來（假設現做要很長時間），只需要領個提貨單就可以了（去幹別的事情），等到蛋糕做好

Java——實現Java多執行緒的三種方法

Java虛擬機器允許應用程式併發地執行多個執行緒。在Java語言中，多執行緒的實現一般有以下3種方法，其中前兩種是最常用的方法。 1.繼承Thread類，重寫run（）方法 Thread本質上也是實現了Runnable介面的一個例項，它代表一個執行緒的例項。並且，啟動執行緒的唯一方法就是通過

Java 多執行緒啟動為什麼呼叫 start() 方法而不是 run() 方法？

多執行緒在工作中多多少少會用到，我們知道啟動**多執行緒呼叫的是 start() 方法，而不是 run() 方法，你知道原因嗎？** 在探討這個問題之前，我們先來了解一些多執行緒的基礎知識~ #### 執行緒的狀態 Java 中，定義了 6 種執行緒狀態，在 Thread 類可以找到： ```java /

Java多執行緒實現電影院售票案例

某電影院目前正在上映賀歲大片，共有100張票，而它有3個售票視窗，請設計一個程式模擬該電影院售票。 定義Sell類實現Runnable介面，很好的解決了單繼承共享資源問題 public class Sell implements Runnable { // 定義100張票，三個售票

Java 多執行緒實現死鎖場景

簡述： 《Java 程式設計思想》  P718 ~ P722 模擬死鎖的場景， 三個人 三根筷子，每個人需要拿到身邊的兩根筷子才能開始吃飯 出現死鎖的場景是，三個人都拿到了右邊的筷子，但是由於筷子都被搶佔，均無法獲得左邊的筷子 Chopstick.java

Java 多執行緒 join和interrupt 方法

簡述： 使用Java多執行緒中join和interrupt函式 《Java程式設計思想》 P669 ~ P670 一個執行緒可以再其他執行緒上呼叫join()方法，其效果是等待一段時間直到第二個執行緒結束才繼續執行。 如果某個執行緒在另一個執行緒t上呼叫t.join(), 此

java:多執行緒(實現Runnable的原理)及二種方式的區別

* 1,看Thread類的建構函式,傳遞了Runnable介面的引用  * 2,通過init()方法找到傳遞的target給成員變數的target賦值 * 3,檢視run方法,發現run方法中有判斷,如果target不為null就會呼叫Runnable介面子類物件的run方法 *

java 多執行緒synchronized鎖同步方法,同步程式碼塊

執行緒安全問題 同步和非同步 我們知道多個執行緒共享堆記憶體,當兩個或者多個執行緒呼叫同一個物件的方法操作物件成員時,因為cpu輪流執行執行緒,執行緒A剛開始操作物件方法,修改了資料,輪到執行緒B執行,執行緒B也操作物件方法,修改資料,可能又輪到執行緒A操作物件方法,接著上次執行緒A的剩餘部

多執行緒實現非同步計算

package cn.itcast.demo6; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future;

Java多執行緒實現的方式

Java多執行緒實現的方式有四種 1.繼承Thread類，重寫run方法 2.實現Runnable介面，重寫run方法，實現Runnable介面的實現類的例項物件作為Thread建構函式的target 3.通過Callable和FutureTask建立執行緒 4.通過執行緒池建立執行

(CSDN遷移) JAVA多執行緒實現-實現Runnable介面

實現Runnable介面  implements Runnable 重寫run()方法 @Override public void run(){//TODO} 建立執行緒物件： Thread thread1 = new Thread(new Implement

(CSDN遷移)JAVA多執行緒實現-單執行緒化執行緒池newSingleThreadExecutor

JAVA通過Executors提供了四種執行緒池，單執行緒化執行緒池(newSingleThreadExecutor)、可控最大併發數執行緒池(newFixedThreadPool)、可回收快取執行緒池(newCachedThreadPool)、支援定時與週期性任務的執行緒池(newScheduledThre

(CSDN遷移) JAVA多執行緒實現-可控最大併發數執行緒池(newFixedThreadPool)

上篇文章中介紹了單執行緒化執行緒池newSingleThreadExecutor，可控最大併發數執行緒池(newFixedThreadPool)與其最大的區別是可以通知執行多個執行緒，可以簡單的將newSingleThreadExecutor理解為newFixedThreadPool(1)。例如執行一下兩個程

Java多執行緒實現以及執行緒安全筆記

Java虛擬機器允許應用程式併發地執行多個執行緒。 以下為多執行緒的實現常用的2種方法 （1）繼承Thread類，重寫run()方法      Thread本質上也是實現了Runnable介面的一個例項，代表一個執行緒的例項。啟用執行緒的唯一方法就是通過Thread類的

java多執行緒-Thread的yield方法

yield表示當前執行緒申請交出執行權，但並不是一定會交出，依賴於系統的執行緒排程。 因此該方法並不穩定。 class Test { public static void main(String[] args) throws InterruptedException { Te

java多執行緒-Thread的sleep方法

public static native void sleep(long millis) throws InterruptedException; sleep是本地靜態方法。sleep的作用是讓執行緒進入TIME_WAITING狀態，引數是多少毫秒。 class Test { pu

用java多執行緒實現一個簡單的水池進出水問題

需求： 有一個水池100L，有出水口和入水口,出水口和入水口不能同時開啟，入水口每次注入5L水，出水口每次出4L水，如果池子注滿水，或者池子中沒有水就停止。 使用繼承Thread類的方式編寫出水口，使用實現Runnable方式編寫入水口，執行結果。 package po

Java多執行緒實現加法計算

採用多執行緒的方式實現從1到N的和 1.直接順序計算 public static void Sum(int N){ long start1 = System.currentTimeMillis(); long sum = 0;

JAVA多執行緒實現的四種方式

         昨天自己用ExecutorService建立執行緒池做穿透測試了一下,感覺挺有意思,所以又好好的看了一下執行緒的問題,在此轉載了一篇博友的文章,感覺總結的不錯,所以分享一下. Java多執行緒實現方式主要有四種： 繼承Thread類、實現Runnable