整個 Netty 的 API 都是異步的,異步處理不是一個新的機制,這個機制出來已經(jīng)有一些時間了。對網(wǎng)絡(luò)應(yīng)用來說,IO 一般是性能的瓶頸,使用異步 IO 可以較大程度上??高程序性能,因為異步變的越來越重要。但是它是如何工作的呢?以及有哪些不同的模式可用呢?

異步處理??倡更有效的使用資源,它允許你創(chuàng)建一個任務(wù),當(dāng)有事件發(fā)生時將獲得通知并等待事件完成。這樣就不會阻塞,不管事件完成與否都會及時返回,資源利用率更高,程序可以利用剩余的資源做一些其他的事情。

本節(jié)將說明一起工作或?qū)崿F(xiàn)異步 API 的兩個最常用的方法,并討論這些技術(shù)之間的差異

一、Callback(回調(diào))

回調(diào)是異步處理的一種技術(shù)。一個回調(diào)是被傳遞到并且執(zhí)行完該方法。
下面代碼是一個簡單的回調(diào)：

public class Worker {    

  public void doWork() {        
    Fetcher fetcher = new MyFetcher(new Data(1, 0));  
    fetcher.fetchData(new FetcherCallback() {     
       
        @Override           
        public void onData(Data data) throws Exception {     
                  System.out.println("Data received : " + data);            
        }            
        @Override            
        public void onError(Throwable cause) {                
            System.out.println("An err occured : " + cause.getMessage());            }        
        });    
   }    

   public static void main(String[] args) {        
        Worker w = new Worker();        
        w.doWork();    
   }
}

public interface Fetcher {    
    void fetchData(FetcherCallback callback);
}

public class MyFetcher implements Fetcher {    
    final Data data;    

    public MyFetcher(Data data) {        
        this.data = data;    
    }    

    @Override    
    public void fetchData(FetcherCallback callback) {        
        try {           
             callback.onData(data);        
        } catch (Exception e) {            
            callback.onError(e);        
        }    
    }
}

public interface FetcherCallback {    

    void onData(Data data) throws Exception;    
    void onError(Throwable cause);
}

public class Data {   
 
    private int m;    
    private int n;    

    public Data(int m, int n) {        
        this.m = m;        
        this.n = n;    
    }    

    @Override    
    public String toString() {        
        int r = n / m;        
        return n + "/" + m + " = " + r;    
    }
}

上面的例子只是一個簡單的模擬回調(diào),要明白其所表達的含義。Fetcher.fetchData()方法需傳遞一個FetcherCallback 類型的參數(shù),當(dāng)獲得數(shù)據(jù)或發(fā)生錯誤時被回調(diào)。對于每種情況都??供了同意的方法:

FetcherCallback.onData(),將接收數(shù)據(jù)時被調(diào)用

FetcherCallback.onError(),發(fā)生錯誤時被調(diào)用

因為可以將這些方法的執(zhí)行從"caller"線程移動到其他的線程執(zhí)行;但也不會保證 FetcherCallback 的每個方法都會被執(zhí)行?；卣{(diào)過程有個問題就是當(dāng)你使用鏈?zhǔn)秸{(diào)用很多不同的方法會導(dǎo)致線性代碼;有些人認(rèn)為這種鏈?zhǔn)秸{(diào)用方法會導(dǎo)致代碼難以閱讀,但是我認(rèn)為這是一種風(fēng)格和習(xí)慣問題。例如,基于 Javascript 的 Node.js 越來越受歡迎,它使用了大量的回調(diào),許多人都認(rèn)為它的這種方式利于閱讀和編寫。

二、Futures

第二種技術(shù)是使用 Futures。Futures 是一個抽象的概念,它表示一個值,該值可能在某一點變得可用。一個 Future 要么獲得計算完的結(jié)果,要么獲得計算失敗后的異常。Java 在 java.util.concurrent 包中附帶了 Future 接口,它使用 Executor 異步執(zhí)行。例如下面的代碼,每傳遞一個 Runnable 對象到 ExecutorService.submit()方法就會得到一個回調(diào)的 Future,你能使用它檢測是否執(zhí)行完成。

public class FutureExample {    
    public static void main(String[] args) {        
        ExecutorService executor = Executors.newCachedThreadPool();        
        Runnable task1 = new Runnable() {            

            @Override            
            public void run() {                
                // do something                
                System.out.println("i am task1...");            
            }        
        };        

        Callable<Integer> task2 = new Callable<Integer>() {            

            @Override            
            public Integer call() throws Exception {                
               // do something                
               return new Integer(100);            
            }        
        };        

        Future<?> f1 = executor.submit(task1);           
        Future<Integer> f2 = executor.submit(task2);    

        System.out.println("task1 is done ? " + f1.isDone());   
        System.out.println("task2 is done ? " + f2.isDone());        

        // waiting task1 done        
        while (f1.isDone()) {            
            System.out.println("task1 done");            
            break;        
        }        
        // waiting task2 done        
        while (f2.isDone()) {            
            System.out.println("task2 done");            
            break;        
        }    
    }
}

有時候使用 Future 感覺很丑陋,因為你需要間隔檢查 Future 是否已完成,而使用回調(diào)會直接收到返回通知?？赐赀@兩個常用的異步執(zhí)行技術(shù)后,你可能想知道使用哪個最好?這里沒有明確的答案。事實上,Netty 兩者都使用,??供兩全其美的方案。