重拾JAVA線程之獲取另一個線程的返回

liuchengxu 發(fā)布于2019-08-19 10:43 / 1660人閱讀

摘要：它將管理線程的創(chuàng)建銷毀和復(fù)用，盡最大可能提高線程的使用效率。如果我們在另一個線程中需要使用這個結(jié)果，則這個線程會掛起直到另一個線程返回該結(jié)果。我們無需再在另一個線程中使用回調(diào)函數(shù)來處理結(jié)果。

前言

Java的多線程機制允許我們將可以并行的任務(wù)分配給不同的線程同時完成。但是，如果我們希望在另一個線程的結(jié)果之上進行后續(xù)操作，我們應(yīng)該怎么辦呢？

注：本文的代碼沒有經(jīng)過具體實踐的檢驗，純屬為了展示。如果有任何問題，歡迎指出。

在此之前你需要了解

Thread類

Runnable接口

ExecutorServer, Executors生成的線程池

一個簡單的場景

假設(shè)我們現(xiàn)在有一個IO操作需要讀取一個文件，在讀取完成之后我們希望針對讀取的字節(jié)進行相應(yīng)的處理。因為IO操作比較耗時，所以我們可能會希望在另一個線程中進行IO操作，從而確保主線程的運行不會出現(xiàn)等待。在這里，我們讀取完文件之后會在其所在線程輸出其字符流對應(yīng)的字符串。

//主線程類
public class MainThread {

    public static void main(String[] args){
        performIO();
    }

    public static void performIO(){
        FileReader fileReader = new FileReader(FILENAME);
        Thread thread = new Thread(fileReader);
        thread.start();
    }
}

文件讀取類：

public class FileReader implements  Runnable{

    private FileInputStream fileInputStream;
    private String fileName;

    private byte[] content;

    public FileReader(String fileName){
        this.fileName = fileName;
        content = new byte[2048];
    }

    @Override
    public void run() {
        try {
            File file = new File(fileName);
            fileInputStream = new FileInputStream(file);
            int bytesRead = 0;
            while(fileInputStream.available() > 0){
                bytesRead += fileInputStream.read(content, bytesRead, content.length - bytesRead);
            }
            System.out.println(new String(content,0, bytesRead));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

一個錯誤的例子

假設(shè)現(xiàn)在主線程希望針對文件的信息進行操作，那么可能會出現(xiàn)以下的代碼：

在子線程中添加get方法返回讀取的字符數(shù)組：

public class FileReader implements Runnable{

    private FileInputStream fileInputStream;
    private String fileName;

    private byte[] content;

    //添加get方法返回字符數(shù)組
    public byte[] getContent(){
        return this.content;
    }
    
    public FileReader(String fileName){
        this.fileName = fileName;
        content = new byte[2048];
    }

    @Override
    public void run() {
        try {
            File file = new File(fileName);
            fileInputStream = new FileInputStream(file);
            int bytesRead = 0;
            while(fileInputStream.available() > 0){
                bytesRead += fileInputStream.read(content, bytesRead, content.length - bytesRead);
            }
            System.out.println(new String(content,0, bytesRead));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

主線程方法中添加讀取byte數(shù)組的方法：

public class MainThread {

    public static void main(String[] args){
        performIO();
    }

    public static void performIO(){
        FileReader fileReader = new FileReader(FILENAME);
        Thread thread = new Thread(fileReader);
        thread.start();

        //讀取內(nèi)容
        byte[] content = fileReader.getContent();
        System.out.println(content);
    }
}

這段代碼不能保證正常運行，原因在于我們無法控制線程的調(diào)度。也就是說，在thread.start()語句后，主線程可能依然占有CPU繼續(xù)執(zhí)行，而此時獲得的content則是null。

你搞定了沒有啊

主線程可以通過輪詢的方式詢問IO線程是不是已經(jīng)完成了操作，如果完成了操作，就讀取結(jié)果。這里我們需要設(shè)置一個標記位來記錄IO是否完成。

public class FileReader implements Runnable{

    private FileInputStream fileInputStream;
    private String fileName;

    private byte[] content;
    //新建標記位，初始為false
    public boolean finish;
    
    public byte[] getContent(){
        return this. content;
    }
    public FileReader(String fileName){
        this.fileName = fileName;
        content = new byte[2048];
    }

    @Override
    public void run() {
        try {
            File file = new File(fileName);
            fileInputStream = new FileInputStream(file);
            int bytesRead = 0;
            while(fileInputStream.available() > 0){
                bytesRead += fileInputStream.read(content, bytesRead, content.length - bytesRead);
            }
            finish = true;
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

主線程一直輪詢IO線程：

public class MainThread {

    public static void main(String[] args){
        performIO();
    }
    
    public static void performIO(){
        FileReader fileReader = new FileReader(FILENAME);
        Thread thread = new Thread(fileReader);
        thread.start();
        while(true){
            if(fileReader.finish){
                System.out.println(new String(fileReader.getContent()));
                break;
            }
        }
    }
}

缺點那是相當(dāng)?shù)拿黠@，不斷的輪詢會無謂的消耗CPU。除此以外，一旦IO異常，則標記位永遠為false，主線程會陷入死循環(huán)。

搞定了告訴我一聲啊

要解決這個問題，我們就需要在IO線程完成讀取之后，通知主線程該操作已經(jīng)完成，從而主線程繼續(xù)運行。這種方法叫做回調(diào)?？梢杂渺o態(tài)方法實現(xiàn)：

public class FileReader implements Runnable{

    private FileInputStream fileInputStream;
    private String fileName;

    private byte[] content;
    
    public FileReader(String fileName){
        this.fileName = fileName;
        content = new byte[2048];
    }

    @Override
    public void run() {
        try {
            File file = new File(fileName);
            fileInputStream = new FileInputStream(file);
            int bytesRead = 0;
            while(fileInputStream.available() > 0){
                bytesRead += fileInputStream.read(content, bytesRead, content.length - bytesRead);
            }
            
            //完成IO后調(diào)用主線程的回調(diào)函數(shù)來通知主線程進行后續(xù)的操作
            MainThread.callback(content);
            
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

主線程方法中定義回調(diào)函數(shù)：

public class MainThread {

    public static void main(String[] args){
        performIO();
    }

    //在主線程中用靜態(tài)方法定義回調(diào)函數(shù)
    public static void callback(byte[] content){
        //do something
        System.out.println(content);
    }
    
    public static void performIO(){
        FileReader fileReader = new FileReader(FILENAME);
        Thread thread = new Thread(fileReader);
        thread.start();
    }
}

這種實現(xiàn)方法的缺點在于MainThread和FileReader類之間的耦合太強了。而且萬一我們需要讀取多個文件，我們會希望對每一個FileReader有自己的callback函數(shù)進行處理。因此我們可以callback將其聲明為一般函數(shù)，并且讓IO線程持有需要回調(diào)的方法所在的實例：

public class FileReader implements Runnable{

    private FileInputStream fileInputStream;
    private String fileName;

    private byte[] content;

    //持有回調(diào)函數(shù)的實例
    private MainThread mainThread;
   
    //傳入實例
    public FileReader(String fileName, MainThreand mainThread){
        this.fileName = fileName;
        content = new byte[2048];
        this.mainThread = mainThread;
    }

    @Override
    public void run() {
        try {
            File file = new File(fileName);
            fileInputStream = new FileInputStream(file);
            int bytesRead = 0;
            while(fileInputStream.available() > 0){
                bytesRead += fileInputStream.read(content, bytesRead, content.length - bytesRead);
            }
            System.out.println(new String(content,0, bytesRead));
            mainThread.callback(content);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

主線程方法中添加讀取byte數(shù)組的方法：

public class MainThread {

    public static void main(String[] args){
        new MainThread().performIO();
    }

    public void callback(byte[] content){
        //do something
    }
    
    //將執(zhí)行IO變?yōu)榉庆o態(tài)方法
    public void performIO(){
        FileReader fileReader = new FileReader(FILENAME);
        Thread thread = new Thread(fileReader);
        thread.start();
    }
}

搞定了告訴我們一聲啊

有時候可能有多個事件都在監(jiān)聽事件，比如當(dāng)我點擊了Button，我希望后臺能夠執(zhí)行查詢操作并將結(jié)果返回給UI。同時,我還希望將用戶的這個操作無論成功與否寫入日志線程。因此，我可以寫兩個回調(diào)函數(shù)，分別對應(yīng)于不同的操作。

public interface Callback{
    public void perform(T t);
}

寫入日志操作：

public class Log implements Callback{
    public void perform(String s){
        //寫入日志
    }
}

IO讀取操作

public class FileReader implements Callback{
    public void perform(String s){
        //進行IO操作
    }
}

public class Button{
    private List callables;
    
    public Button(){
        callables = new ArrayList();
    }
    
    public void addCallable(Callable c){
        this.callables.add(c);
    }
    
    public void onClick(){
        for(Callable c : callables){
            c.perform(...);
        }
    }
}

Java7: 行了，別忙活了，朕知道了

Java7提供了非常方便的封裝Future，Callables和Executors來實現(xiàn)之前的回調(diào)工作。

之前我們直接將任務(wù)交給一個新建的線程來處理。可是如果每次都新建一個線程來處理當(dāng)前的任務(wù)，線程的新建和銷毀將會是一大筆開銷。因此Java提供了多種類型的線程池來供我們操作。它將管理線程的創(chuàng)建銷毀和復(fù)用，盡最大可能提高線程的使用效率。

同時Java7提供的Callable接口將自動返回線程運行結(jié)束的結(jié)果。如果我們在另一個線程中需要使用這個結(jié)果，則這個線程會掛起直到另一個線程返回該結(jié)果。我們無需再在另一個線程中使用回調(diào)函數(shù)來處理結(jié)果。

假設(shè)現(xiàn)在我們想要找到一個數(shù)組的最大值。假設(shè)該數(shù)組容量驚人，因此我們希望新開兩個線程分別對數(shù)組的前半部分和后半部分計算最大值。然后在主線程中比較兩個結(jié)果得出結(jié)論：

public class ArrayMaxValue {

    public static void main(String[] args){

        Random r = new Random(20);
        int[] array = new int[500];
        for (int i = 0 ; i f1 = executorService.submit(new MaxValue(array, 0, mid));
        Future f2 = executorService.submit(new MaxValue(array, mid, array.length));

        try {
            //主線程將阻塞自己直到兩個線程都完成運行，并返回結(jié)果
            System.out.println(Math.max(f1.get(), f2.get()));
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
    public class MaxValue implements Callable{
        private final int[] array;
        private final int startIndex;
        private final int endIndex;
        public MaxValue(int[] array, int startIndex, int endIndex){
            this.array = array;
            this.startIndex = startIndex;
            this.endIndex = endIndex;
        }
        @Override
        public Integer call() throws Exception {
            int max = Integer.MIN_VALUE;
            for (int i = startIndex ; i
參考文章
深入理解線程通信

想要了解更多開發(fā)技術(shù)，面試教程以及互聯(lián)網(wǎng)公司內(nèi)推，歡迎關(guān)注我的微信公眾號！將會不定期的發(fā)放福利哦~

GPU云服務(wù)器云服務(wù)器 java線程的返回值 java線程返回值 java線程如何返回值 java監(jiān)聽一個線程

文章版權(quán)歸作者所有，未經(jīng)允許請勿轉(zhuǎn)載,若此文章存在違規(guī)行為，您可以聯(lián)系管理員刪除。

轉(zhuǎn)載請注明本文地址：http://www.ezyhdfw.cn/yun/76369.html

發(fā)表評論

登陸后可評論

0條評論

liuchengxu

男|高級講師

我要關(guān)注我要私信

TA的文章

[11.11]spinservers云服務(wù)器5折$19/月起,雙核,8G內(nèi)存,200G SSD,10

閱讀 1685·2021-11-11 10:59
Linphone SIP堆棧錯誤可允許攻擊者遠程使客戶端設(shè)備崩潰

閱讀 2694·2021-09-04 16:40
【Python】一文弄懂python裝飾器（附源碼例子）

閱讀 3733·2021-09-04 16:40
PacificRack站群VPS限時五折,8核16G內(nèi)存61個IP僅50美元

閱讀 3076·2021-07-30 15:30
UCloud快杰云主機速度及綜合性能測評,UCloud特惠云服務(wù)器領(lǐng)券購買詳細過程,國內(nèi)BGP/香港

閱讀 1816·2021-07-26 22:03
我所知道的flex布局-下篇（語法）

閱讀 3223·2019-08-30 13:20
我的前端規(guī)范系列-前端專屬的目錄結(jié)構(gòu)[解決項目中的釘子戶]

閱讀 2298·2019-08-29 18:31
前端基礎(chǔ)知識學(xué)習(xí)記錄（一）

閱讀 499·2019-08-29 12:21

亚洲中字慕日产2020,大陆极品少妇内射AAAAAA,无码av大香线蕉伊人久久,久久精品国产亚洲av麻豆网站

資訊專欄INFORMATION COLUMN

上云采購季！| 2核2G4M爆款云服務(wù)器低至59元/年，更有多臺、長期優(yōu)惠，快來選購！

重拾JAVA線程之獲取另一個線程的返回

相關(guān)文章

**重拾 Java 基礎(chǔ)**

**重拾Java Network Programming（二）InetAddress**

**重拾Java Network Programming（四）URLConnection & C**

**重拾Java Network Programming（四）URLConnection & C**

后臺 - 收藏集 - 掘金

發(fā)表評論

0條評論

liuchengxu

男|高級講師

TA的文章

[11.11]spinservers云服務(wù)器5折$19/月起,雙核,8G內(nèi)存,200G SSD,10

Linphone SIP堆棧錯誤可允許攻擊者遠程使客戶端設(shè)備崩潰

【Python】一文弄懂python裝飾器（附源碼例子）

PacificRack站群VPS限時五折,8核16G內(nèi)存61個IP僅50美元

UCloud快杰云主機速度及綜合性能測評,UCloud特惠云服務(wù)器領(lǐng)券購買詳細過程,國內(nèi)BGP/香港

我所知道的flex布局-下篇（語法）

我的前端規(guī)范系列-前端專屬的目錄結(jié)構(gòu)[解決項目中的釘子戶]

前端基礎(chǔ)知識學(xué)習(xí)記錄（一）

最新活動

資訊專欄INFORMATION COLUMN

上云采購季！| 2核2G4M爆款云服務(wù)器低至59元/年，更有多臺、長期優(yōu)惠，快來選購！

重拾JAVA線程之獲取另一個線程的返回

相關(guān)文章

發(fā)表評論

0條評論

男|高級講師

TA的文章

最新活動

上云采購季！| 2核2G4M爆款云服務(wù)器低至59元/年，更有多臺、長期優(yōu)惠，快來選購！