Callable、Future&阻塞隊列&阻塞棧

Callable、Future   簡單應用                                                         

在Java5之前，線程是沒有返回值的，常常為了“有”返回值，破費周折，而且代碼很不好寫。或者干脆繞過這道坎，走別的路了。現在Java終於有可返回值的任務（也可以叫做線程）了。

可返回值的任務必須實現Callable接口，類似的，無返回值的任務必須Runnable接口。執行Callable任務后，可以獲取一個Future的對象，在該對象上調用get就可以獲取到Callable任務返回的Object了。

Code                                                                                   

public class Test { 
        public static void main(String[] args) throws ExecutionException, InterruptedException { 
                //創建一個線程池 
                ExecutorService pool = Executors.newFixedThreadPool(2); 
                //創建兩個有返回值的任務 
                Callable c1 = new MyCallable("A"); 
                Callable c2 = new MyCallable("B"); 
                //執行任務並獲取Future對象 
                Future f1 = pool.submit(c1); 
                Future f2 = pool.submit(c2); 
                //從Future對象上獲取任務的返回值，並輸出到控制台 
                System.out.println(">>>"+f1.get().toString()); 
                System.out.println(">>>"+f2.get().toString()); 
                //關閉線程池 
                pool.shutdown(); 
        } 
} 

class MyCallable implements Callable{ 
        private String oid; 

        MyCallable(String oid) { 
                this.oid = oid; 
        } 

        @Override 
        public Object call() throws Exception { 
                return oid+"任務返回的內容"; 
        } 
}

>>>A任務返回的內容 
>>>B任務返回的內容

阻塞隊列   簡單應用                                                                 

阻塞隊列是Java5線程新特征中的內容，Java定義了阻塞隊列的接口java.util.concurrent.BlockingQueue，阻塞隊列的概念是，一個指定長度的隊列，如果隊列滿了，添加新元素的操作會被阻塞等待，直到有空位為止。同樣，當隊列為空時候，請求隊列元素的操作同樣會阻塞等待，直到有可用元素為止。

有了這樣的功能，就為多線程的排隊等候的模型實現開辟了便捷通道，非常有用。

Code                                                                                   

public class Test { 
        public static void main(String[] args) throws InterruptedException { 
                BlockingQueue bqueue = new ArrayBlockingQueue(20); 
                for (int i = 0; i < 30; i++) { 
                        //將指定元素添加到此隊列中，如果沒有可用空間，將一直等待（如果有必要）。 
                        bqueue.put(i); 
                        System.out.println("向阻塞隊列中添加了元素:" + i); 
                } 
                System.out.println("程序到此運行結束，即將退出----"); 
        } 
}

向阻塞隊列中添加了元素:0 
向阻塞隊列中添加了元素:1 
向阻塞隊列中添加了元素:2 
向阻塞隊列中添加了元素:3 
向阻塞隊列中添加了元素:4 
向阻塞隊列中添加了元素:5 
向阻塞隊列中添加了元素:6 
向阻塞隊列中添加了元素:7 
向阻塞隊列中添加了元素:8 
向阻塞隊列中添加了元素:9 
向阻塞隊列中添加了元素:10 
向阻塞隊列中添加了元素:11 
向阻塞隊列中添加了元素:12 
向阻塞隊列中添加了元素:13 
向阻塞隊列中添加了元素:14 
向阻塞隊列中添加了元素:15 
向阻塞隊列中添加了元素:16 
向阻塞隊列中添加了元素:17 
向阻塞隊列中添加了元素:18 
向阻塞隊列中添加了元素:19

可以看出，輸出到元素19時候，就一直處於等待狀態，因為隊列滿了，程序阻塞了。

阻塞棧     簡單應用                                                                  

對於阻塞棧，與阻塞隊列相似。不同點在於棧是“后入先出”的結構，每次操作的是棧頂，而隊列是“先進先出”的結構，每次操作的是隊列頭。Java為阻塞棧定義了接口：java.util.concurrent.BlockingDeque。

Code                                                                                   

public class Test { 
        public static void main(String[] args) throws InterruptedException { 
                BlockingDeque bDeque = new LinkedBlockingDeque(20); 
                for (int i = 0; i < 30; i++) { 
                        //將指定元素添加到此阻塞棧中，如果沒有可用空間，將一直等待（如果有必要）。 
                        bDeque.putFirst(i); 
                        System.out.println("向阻塞棧中添加了元素:" + i); 
                } 
                System.out.println("程序到此運行結束，即將退出----"); 
        } 
}

向阻塞棧中添加了元素:0 
向阻塞棧中添加了元素:1 
向阻塞棧中添加了元素:2 
向阻塞棧中添加了元素:3 
向阻塞棧中添加了元素:4 
向阻塞棧中添加了元素:5 
向阻塞棧中添加了元素:6 
向阻塞棧中添加了元素:7 
向阻塞棧中添加了元素:8 
向阻塞棧中添加了元素:9 
向阻塞棧中添加了元素:10 
向阻塞棧中添加了元素:11 
向阻塞棧中添加了元素:12 
向阻塞棧中添加了元素:13 
向阻塞棧中添加了元素:14 
向阻塞棧中添加了元素:15 
向阻塞棧中添加了元素:16 
向阻塞棧中添加了元素:17 
向阻塞棧中添加了元素:18 
向阻塞棧中添加了元素:19

從上面結果可以看到，程序並沒結束，二是阻塞住了，原因是棧已經滿了，后面追加元素的操作都被阻塞了。

我是天王蓋地虎的分割線