import java.util.concurrent.ExecutorService;


import java.util.concurrent.Executors;  

public class MyExecutor extends Thread {  
    private int index;  
    public MyExecutor(int i) {  
        this.index = i;  
    }  
    public void run() {  
        try {  
            System.out.println("[" + this.index + "] start....");  
            Thread.sleep((int) (Math.random() * 1000));  
            System.out.println("[" + this.index + "] end.");  
        }catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  

    public static void main(String args[]) {  
        ExecutorService service = Executors.newFixedThreadPool(4);  
        for (int i = 0; i < 10; i++) {  
            service.execute(new MyExecutor(i));  
            // service.submit(new MyExecutor(i));  
        }  
        System.out.println("submit finish");  
        service.shutdown();  
    }  

}  </pre><a style="text-indent:0px;" title="派生到我的代碼片" href="/misc/goto?guid=4959551975775292877" target="_blank"></a></div>

</div>
</div>
雖然打印了一些信息，但是看的不是非常清晰，這個線程池是如何工作的，我們來將休眠的時間調長10倍。

Thread.sleep((int)(Math.random()*10000));

再來看，會清楚看到只能執行4個線程。當執行完一個線程后，才會又執行一個新的線程，也就是說，我們將所有的線程提交后，線程池會等待執行完最后 shutdown。我們也會發現，提交的線程被放到一個“無界隊列里”。這是一個有序隊列（BlockingQueue，這個下面會說到）。

另外它使用了Executors的靜態函數生成一個固定的線程池，顧名思義，線程池的線程是不會釋放的，即使它是Idle。

這就會產生性能問題，比如如果線程池的大小為200，當全部使用完畢后，所有的線程會繼續留在池中，相應的內存和線程切換（while(true)+sleep循環）都會增加。

如果要避免這個問題，就必須直接使用ThreadPoolExecutor()來構造。可以像通用的線程池一樣設置“最大線程數”、“最小線程數”和“空閑線程keepAlive的時間”。

這個就是線程池基本用法。



Semaphore
一個計數信號量。從概念上講，信號量維護了一個許可集合。如有必要，在許可可用前會阻塞每一個 acquire()，然后再獲取該許可。每個 release() 添加一個許可，從而可能釋放一個正在阻塞的獲取者。但是，不使用實際的許可對象，Semaphore 只對可用許可的號碼進行計數，并采取相應的行動。

Semaphore 通常用于限制可以訪問某些資源（物理或邏輯的）的線程數目。例如，下面的類使用信號量控制對內容池的訪問：

這里是一個實際的情況，大家排隊上廁所，廁所只有兩個位置，來了10個人需要排隊。

 


    import java.util.concurrent.ExecutorService;


import java.util.concurrent.Executors;  

import java.util.concurrent.Semaphore;  

public class MySemaphore extends Thread {  
    private Semaphore position;  
    private int id;  

    public MySemaphore(int i, Semaphore s) {  
        this.id = i;  
        this.position = s;  
    }  

    public void run() {  
        try {  
            //有沒有空廁所  
            if (position.availablePermits() > 0) {  
                System.out.println("顧客[" + this.id + "]進入廁所，有空位");  
            }else {  
                System.out.println("顧客[" + this.id + "]進入廁所，沒空位，排隊");  
            }  
            //獲取到空廁所了  
            position.acquire();  
            System.out.println("顧客[" + this.id + "]獲得坑位");  
            //使用中...  
            Thread.sleep((int) (Math.random() * 1000));  
            System.out.println("顧客[" + this.id + "]使用完畢");  
            //廁所使用完之后釋放  
            position.release();  
        }catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  

    public static void main(String args[]) {  
        ExecutorService list = Executors.newCachedThreadPool();  
        Semaphore position = new Semaphore(2);//只有兩個廁所  
        //有十個人  
        for (int i = 0; i < 10; i++) {  
            list.submit(new MySemaphore(i + 1, position));  
        }  
        list.shutdown();  
        position.acquireUninterruptibly(2);  
        System.out.println("使用完畢，需要清掃了");  
        position.release(2);  
    }  

}  </pre><a style="text-indent:0px;" title="派生到我的代碼片" href="/misc/goto?guid=4959551975775292877" target="_blank"></a></div>

</div>
</div>


ReentrantLock
一個可重入的互斥鎖定 Lock，它具有與使用 synchronized 方法和語句所訪問的隱式監視器鎖定相同的一些基本行為和語義，但功能更強大。他們兩個的區別見：http://blog.csdn.net/fw0124/article/details/6672522

ReentrantLock 將由最近成功獲得鎖定，并且還沒有釋放該鎖定的線程所擁有。當鎖定沒有被另一個線程所擁有時，調用 lock 的線程將成功獲取該鎖定并返回。如果當前線程已經擁有該鎖定，此方法將立即返回。可以使用 isHeldByCurrentThread() 和 getHoldCount() 方法來檢查此情況是否發生。

此類的構造方法接受一個可選的公平參數。

當設置為 true時，在多個線程的爭用下，這些鎖定傾向于將訪問權授予等待時間最長的線程。否則此鎖定將無法保證任何特定訪問順序。

與采用默認設置（使用不公平鎖定）相比，使用公平鎖定的程序在許多線程訪問時表現為很低的總體吞吐量（即速度很慢，常常極其慢），但是在獲得鎖定和保證鎖定分配的均衡性時差異較小。不過要注意的是，公平鎖定不能保證線程調度的公平性。因此，使用公平鎖定的眾多線程中的一員可能獲得多倍的成功機會，這種情況發生在其他活動線程沒有被處理并且目前并未持有鎖定時。還要注意的是，未定時的 tryLock 方法并沒有使用公平設置。因為即使其他線程正在等待，只要該鎖定是可用的，此方法就可以獲得成功。

建議總是 立即實踐，使用 try 塊來調用 lock，在之前/之后的構造中，最典型的代碼如下：

 


    class X {  
        private final ReentrantLock lock = new ReentrantLock();  
        // ...  
        public void m() {  
            lock.lock(); // block until condition holds  
            try {  
                // ... method body  
            }finally {  
                lock.unlock()  
            }  
        }  
    }  

</div>
</div>


我的例子：



    import java.util.concurrent.ExecutorService;


import java.util.concurrent.Executors;  

import java.util.concurrent.locks.ReentrantLock;  

public class MyReentrantLock extends Thread {  

    TestReentrantLock lock;  
    private int id;  

    public MyReentrantLock(int i, TestReentrantLock test) {  
        this.id = i;  
        this.lock = test;  
    }  

    public void run() {  
        lock.print(id);  
    }  

    public static void main(String args[]) {  
        ExecutorService service = Executors.newCachedThreadPool();  
        TestReentrantLock lock = new TestReentrantLock();  
        for (int i = 0; i < 10; i++) {  
            service.submit(new MyReentrantLock(i, lock));  
        }  
        service.shutdown();  
    }  

}  

class TestReentrantLock {  
    private ReentrantLock lock = new ReentrantLock();  
    public void print(int str) {  
        try {  
            lock.lock();  
            System.out.println(str + "獲得");  
            Thread.sleep((int) (Math.random() * 1000));  
        }catch (Exception e) {  
            e.printStackTrace();  
        }finally {  
            System.out.println(str + "釋放");  
            lock.unlock();  
        }  
    }  

}  </pre><a style="text-indent:0px;" title="派生到我的代碼片" href="/misc/goto?guid=4959551975775292877" target="_blank"></a></div>

</div>
</div>


BlockingQueue
支持兩個附加操作的 Queue，這兩個操作是：檢索元素時等待隊列變為非空，以及存儲元素時等待空間變得可用。

BlockingQueue 不接受 null 元素。試圖 add、put 或 offer 一個 null 元素時，某些實現會拋出 NullPointerException。null 被用作指示 poll 操作失敗的警戒值。

BlockingQueue 可以是限定容量的。它在任意給定時間都可以有一個 remainingCapacity，超出此容量，便無法無阻塞地 put 額外的元素。

沒有任何內部容量約束的 BlockingQueue 總是報告 Integer.MAX_VALUE 的剩余容量。

BlockingQueue 實現主要用于生產者-使用者隊列，但它另外還支持 Collection 接口。因此，舉例來說，使用 remove(x) 從隊列中移除任意一個元素是有可能的。

然而，這種操作通常不 會有效執行，只能有計劃地偶爾使用，比如在取消排隊信息時。

BlockingQueue 實現是線程安全的。所有排隊方法都可以使用內部鎖定或其他形式的并發控制來自動達到它們的目的。

然而，大量的 Collection 操作（addAll、containsAll、retainAll 和 removeAll）沒有 必要自動執行，除非在實現中特別說明。

因此，舉例來說，在只添加了 c 中的一些元素后，addAll(c) 有可能失敗（拋出一個異常）。

BlockingQueue 實質上不 支持使用任何一種“close”或“shutdown”操作來指示不再添加任何項。

這種功能的需求和使用有依賴于實現的傾向。例如，一種常用的策略是：對于生產者，插入特殊的 end-of-stream 或 poison 對象，并根據使用者獲取這些對象的時間來對它們進行解釋。</div>



下面的例子演示了這個阻塞隊列的基本功能。



 


    import java.util.concurrent.BlockingQueue;


import java.util.concurrent.ExecutorService;  

import java.util.concurrent.Executors;  

import java.util.concurrent.LinkedBlockingQueue;  

public class MyBlockingQueue extends Thread {  

    public static BlockingQueue<String> queue = new LinkedBlockingQueue<String>(3);  
    private int index;  

    public MyBlockingQueue(int i) {  
        this.index = i;  
    }  

    public void run() {  
        try {  
            queue.put(String.valueOf(this.index));  
            System.out.println("{" + this.index + "} in queue!");  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  

    public static void main(String args[]) {  
        ExecutorService service = Executors.newCachedThreadPool();  
        for (int i = 0; i < 10; i++) {  
            service.submit(new MyBlockingQueue(i));  
        }  

        Thread thread = new Thread() {  
            public void run() {  
                try {  
                    while (true) {  
                        Thread.sleep((int) (Math.random() * 1000));  
                        if (MyBlockingQueue.queue.isEmpty())  
                            break;  
                        String str = MyBlockingQueue.queue.take();  
                        System.out.println(str + " has take!");  
                    }  
                } catch (Exception e) {  
                    e.printStackTrace();  
                }  
            }  
        };  
        service.submit(thread);  
        service.shutdown();  
    }  

}  </pre><a style="text-indent:0px;" title="派生到我的代碼片" href="/misc/goto?guid=4959551975775292877" target="_blank"></a></div>

</div>
</div>


---------------------執行結果-----------------

{0} in queue!

{1} in queue!

{2} in queue!

{3} in queue!

0 has take!

{4} in queue!

1 has take!

{6} in queue!

2 has take!

{7} in queue!

3 has take!

{8} in queue!

4 has take!

{5} in queue!

6 has take!

{9} in queue!

7 has take!

8 has take!

5 has take!

9 has take!

-----------------------------------------



CompletionService
我們現在在Java中使用多線程通常不會直接用Thread對象了，而是會用到 java.util.concurrent包下的ExecutorService類來初始化一個線程池供我們使用。之前我一直習慣自己維護一個list保存submit的callable task所返回的Future對象。在主線程中遍歷這個list并調用Future的get()方法取到Task的返回值。但是，我在很多地方會看到一些代碼通過CompletionService包裝ExecutorService，然后調用其take()方法去取Future對象。以前沒研究過這兩者之間的區別。今天看了源代碼之后就明白了。這兩者最主要的區別在于submit的task不一定是按照加入自己維護的list順序完成的。

從list中遍歷的每個Future對象并不一定處于完成狀態，這時調用get()方法就會被阻塞住，如果系統是設計成每個線程完成后就能根據其結果繼續做后面的事，這樣對于處于list后面的但是先完成的線程就會增加了額外的等待時間。而CompletionService的實現是維護一個保存 Future對象的BlockingQueue。只有當這個Future對象狀態是結束的時候，才會加入到這個Queue中，take()方法其實就是 Producer-Consumer中的Consumer。它會從Queue中取出Future對象，如果Queue是空的，就會阻塞在那里，直到有完成的Future對象加入到Queue中。

所以，先完成的必定先被取出。這樣就減少了不必要的等待時間。ExecutorCompletionService 類提供了此方法的一個實現。



 


    import java.util.concurrent.Callable;


import java.util.concurrent.CompletionService;  

import java.util.concurrent.ExecutorCompletionService;  

import java.util.concurrent.ExecutorService;  

import java.util.concurrent.Executors;  

public class MyCompletionService implements Callable<String> {  
    private int id;  
    public MyCompletionService(int i) {  
        this.id = i;  
    }  

    public static void main(String[] args) throws Exception {  
        ExecutorService service = Executors.newCachedThreadPool();  
        CompletionService<String> completion = new ExecutorCompletionService<String>(service);  
        for (int i = 0; i < 10; i++) {  
            completion.submit(new MyCompletionService(i));  
        }  

        for (int i = 0; i < 10; i++) {  
            System.out.println(completion.take().get());  
        }  
        service.shutdown();  
    }  

    public String call() throws Exception {  
        Integer time = (int) (Math.random() * 1000);  
        try {  
            System.out.println(this.id + " start");  
            Thread.sleep(time);  
            System.out.println(this.id + " end");  
        }catch (Exception e) {  
            e.printStackTrace();  
        }  
        return this.id + ":" + time;  
    }  

}  </pre><a style="text-indent:0px;" title="派生到我的代碼片" href="/misc/goto?guid=4959551975775292877" target="_blank"></a></div>

</div>
</div>


CountDownLatch
一個同步輔助類，在完成一組正在其他線程中執行的操作之前，它允許一個或多個線程一直等待。

用給定的計數 初始化 CountDownLatch。由于調用了 countDown() 方法，所以在當前計數到達零之前，await 方法會一直受阻塞。

之后，會釋放所有等待的線程，await 的所有后續調用都將立即返回。這種現象只出現一次——計數無法被重置。如果需要重置計數，請考慮使用 CyclicBarrier。

CountDownLatch 是一個通用同步工具，它有很多用途。將計數 1 初始化的 CountDownLatch 用作一個簡單的開/關鎖存器，

或入口：在通過調用 countDown() 的線程打開入口前，所有調用 await 的線程都一直在入口處等待。

用 N 初始化的 CountDownLatch 可以使一個線程在 N 個線程完成某項操作之前一直等待，或者使其在某項操作完成 N 次之前一直等待。

CountDownLatch 的一個有用特性是，它不要求調用 countDown 方法的線程等到計數到達零時才繼續，而在所有線程都能通過之前，它只是阻止任何線程繼續通過一個 await。



下面的例子是別人寫的，非常形象。



 


    import java.util.concurrent.CountDownLatch;


import java.util.concurrent.ExecutorService;  

import java.util.concurrent.Executors;  

public class TestCountDownLatch {  

    public static void main(String[] args) throws InterruptedException {  
        // 開始的倒數鎖  
        final CountDownLatch begin = new CountDownLatch(1);  
        // 結束的倒數鎖  
        final CountDownLatch end = new CountDownLatch(10);  
        // 十名選手  
        final ExecutorService exec = Executors.newFixedThreadPool(10);  
        for (int index = 0; index < 10; index++) {  
            final int NO = index + 1;  
            Runnable run = new Runnable() {  
                public void run() {  
                    try {  
                        begin.await();// 一直阻塞  
                        Thread.sleep((long) (Math.random() * 10000));  
                        System.out.println("No." + NO + " arrived");  
                    } catch (InterruptedException e) {  
                    } finally {  
                        end.countDown();  
                    }  
                }  
            };  
            exec.submit(run);  
        }  
        System.out.println("Game Start");  
        begin.countDown();  
        end.await();  
        System.out.println("Game Over");  
        exec.shutdown();  
    }  
}  </pre><a style="text-indent:0px;" title="派生到我的代碼片" href="/misc/goto?guid=4959551975775292877" target="_blank"></a></div>

</div>
</div>


CountDownLatch最重要的方法是countDown()和await()，前者主要是倒數一次，后者是等待倒數到0，如果沒有到達0，就只有阻塞等待了。



CyclicBarrier
一個同步輔助類，它允許一組線程互相等待，直到到達某個公共屏障點 (common barrier point)。

在涉及一組固定大小的線程的程序中，這些線程必須不時地互相等待，此時 CyclicBarrier 很有用。因為該 barrier 在釋放等待線程后可以重用，所以稱它為循環 的 barrier。

CyclicBarrier 支持一個可選的 Runnable 命令，在一組線程中的最后一個線程到達之后（但在釋放所有線程之前），該命令只在每個屏障點運行一次。若在繼續所有參與線程之前更新共享狀態，此屏障操作 很有用。</div>



示例用法：下面是一個在并行分解設計中使用 barrier 的例子，很經典的旅行團例子：



 


    import java.text.SimpleDateFormat;


import java.util.Date;  

import java.util.concurrent.BrokenBarrierException;  

import java.util.concurrent.CyclicBarrier;  

import java.util.concurrent.ExecutorService;  

import java.util.concurrent.Executors;  

public class TestCyclicBarrier {  

    // 徒步需要的時間: Shenzhen, Guangzhou, Shaoguan, Changsha, Wuhan  

    private static int[] timeWalk = { 5, 8, 15, 15, 10 };  
    // 自駕游  
    private static int[] timeSelf = { 1, 3, 4, 4, 5 };  
    // 旅游大巴  
    private static int[] timeBus = { 2, 4, 6, 6, 7 };  

    static String now() {  
        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");  
        return sdf.format(new Date()) + ": ";  

    }  

    static class Tour implements Runnable {  

        private int[] times;  
        private CyclicBarrier barrier;  
        private String tourName;  

        public Tour(CyclicBarrier barrier, String tourName, int[] times) {  
            this.times = times;  
            this.tourName = tourName;  
            this.barrier = barrier;  
        }  

        public void run() {  
            try {  
                Thread.sleep(times[0] * 1000);  
                System.out.println(now() + tourName + " Reached Shenzhen");  
                barrier.await();  
                Thread.sleep(times[1] * 1000);  
                System.out.println(now() + tourName + " Reached Guangzhou");  
                barrier.await();  
                Thread.sleep(times[2] * 1000);  
                System.out.println(now() + tourName + " Reached Shaoguan");  
                barrier.await();  
                Thread.sleep(times[3] * 1000);  
                System.out.println(now() + tourName + " Reached Changsha");  
                barrier.await();  
                Thread.sleep(times[4] * 1000);  
                System.out.println(now() + tourName + " Reached Wuhan");  
                barrier.await();  
            } catch (InterruptedException e) {  
            } catch (BrokenBarrierException e) {  
            }  
        }  
    }  

    public static void main(String[] args) {  
        // 三個旅行團  
        CyclicBarrier barrier = new CyclicBarrier(3);  
        ExecutorService exec = Executors.newFixedThreadPool(3);  
        exec.submit(new Tour(barrier, "WalkTour", timeWalk));  
        exec.submit(new Tour(barrier, "SelfTour", timeSelf));  
        // 當我們把下面的這段代碼注釋后，會發現，程序阻塞了，無法繼續運行下去。  
        exec.submit(new Tour(barrier, "BusTour", timeBus));  
        exec.shutdown();  
    }  

}  </pre><a style="text-indent:0px;" title="派生到我的代碼片" href="/misc/goto?guid=4959551975775292877" target="_blank"></a></div>

</div>
</div>


CyclicBarrier最重要的屬性就是參與者個數，另外最要方法是await()。當所有線程都調用了await()后，就表示這些線程都可以繼續執行，否則就會等待。



Future
Future 表示異步計算的結果。它提供了檢查計算是否完成的方法，以等待計算的完成，并檢索計算的結果。

計算完成后只能使用 get 方法來檢索結果，如有必要，計算完成前可以阻塞此方法。取消則由 cancel 方法來執行。

還提供了其他方法，以確定任務是正常完成還是被取消了。一旦計算完成，就不能再取消計算。

如果為了可取消性而使用 Future但又不提供可用的結果，則可以聲明 Future<?> 形式類型、并返回 null 作為基礎任務的結果。

這個我們在前面CompletionService已經看到了，這個Future的功能，而且這個可以在提交線程的時候被指定為一個返回對象的。</div>

看下面的例子：



    import java.util.concurrent.Callable;

    import java.util.concurrent.ExecutionException;

    import java.util.concurrent.ExecutorService;

    import java.util.concurrent.Executors;

    import java.util.concurrent.Future;

    public class MyFutureTask {

        /**


     * @param args 
     * @throws InterruptedException  
     * @throws ExecutionException 
     * @throws InterruptedException 
     * @throws ExecutionException  
     */  
    public static void main(String[] args) throws InterruptedException, ExecutionException {  

        final ExecutorService exe=Executors.newFixedThreadPool(3);  
        Callable<String> call=new Callable<String>(){  
            public String call() throws InterruptedException {  
                return "Thread is finished";  
            }  
        };  
        Future<String> task=exe.submit(call);  
        String obj=task.get();  
        System.out.println(obj+"進程結束");  
        System.out.println("總進程結束");  
        exe.shutdown();  
    }  
}  
class MyThreadTest implements Runnable {  
    private String str;  
    public MyThreadTest(String str) {  
        this.str = str;  
    }  
    public void run() {  
        this.setStr("allen"+str);  
    }  
    public void addString(String str) {  
        this.str = "allen:" + str;  
    }  
    public String getStr() {  
        return str;  
    }  
    public void setStr(String str) {  
        this.str = str;  
    }  
}  </pre><a style="text-indent:0px;" title="派生到我的代碼片" href="/misc/goto?guid=4959551975775292877" target="_blank"></a></div>

</div>
</div>


ScheduledExecutorService
一個 ExecutorService，可安排在給定的延遲后運行或定期執行的命令。

schedule 方法使用各種延遲創建任務，并返回一個可用于取消或檢查執行的任務對象。scheduleAtFixedRate 和 scheduleWithFixedDelay 方法創建并執行某些在取消前一直定期運行的任務。

用 Executor.execute(java.lang.Runnable) 和 ExecutorService 的 submit 方法所提交的命令，通過所請求的 0 延遲進行安排。

schedule 方法中允許出現 0 和負數延遲（但不是周期），并將這些視為一種立即執行的請求。

所有的 schedule 方法都接受相對 延遲和周期作為參數，而不是絕對的時間或日期。將以 Date 所表示的絕對時間轉換成要求的形式很容易。

例如，要安排在某個以后的日期運行，可以使用：schedule(task, date.getTime() - System.currentTimeMillis(), TimeUnit.MILLISECONDS)。

但是要注意，由于網絡時間同步協議、時鐘漂移或其他因素的存在，因此相對延遲的期滿日期不必與啟用任務的當前 Date 相符。

Executors 類為此包中所提供的 ScheduledExecutorService 實現提供了便捷的工廠方法。



下面的例子也是網上比較流行的。

    import static java.util.concurrent.TimeUnit.SECONDS;


import java.util.Date;  

import java.util.concurrent.Executors;  

import java.util.concurrent.ScheduledExecutorService;  

import java.util.concurrent.ScheduledFuture;  

public class TestScheduledThread {  
    public static void main(String[] args) {  
        final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);  
        final Runnable beeper = new Runnable() {  
            int count = 0;  
            public void run() {  
                System.out.println(new Date() + " beep " + (++count));  
            }  
        };  

        // 1秒鐘后運行，并每隔2秒運行一次  
        final ScheduledFuture beeperHandle = scheduler.scheduleAtFixedRate(beeper, 1, 2, SECONDS);  
        // 2秒鐘后運行，并每次在上次任務運行完后等待5秒后重新運行  
        final ScheduledFuture beeperHandle2 = scheduler.scheduleWithFixedDelay(beeper, 2, 5, SECONDS);  
        // 30秒后結束關閉任務，并且關閉Scheduler  
        scheduler.schedule(new Runnable() {  
            public void run() {  
                beeperHandle.cancel(true);  
                beeperHandle2.cancel(true);  
                scheduler.shutdown();  
            }  

        }, 30, SECONDS);  

    }  

}  </pre> <div class="dp-highlighter bg_java">



</div>
</div>


這樣我們就把concurrent包下比較重要的功能都已經總結完了，希望對我們理解能有幫助。



來自：http://blog.csdn.net/jiangwei0910410003/article/details/20373497

                    
                    

                        
 本文由用戶 jopen 自行上傳分享，僅供網友學習交流。所有權歸原作者，若您的權利被侵害，請聯系管理員。
                        
 轉載本站原創文章，請注明出處，并保留原始鏈接、圖片水印。
                        
 本站是一個以用戶分享為主的開源技術平臺，歡迎各類分享！
                        
 本文地址：http://www.baiduhome.net/lib/view/open1393834656896.html
                        
 Java Java開發
                    

                
                

                    

                        
相關經驗
                        

 
 Java中的并發庫學習總結
  
 JAVA多線程與并發學習總結
  
 Java5 并發學習
  
 Java IO流學習總結
  
 Java IO流學習總結
                         
                    
                    

                        
相關資訊
                        

 
 25個Java機器學習工具&庫
  
 25 個 Java 機器學習工具和庫
  
 Android 6.0中的新技術總結
  
 Objective-C Runtime中的并發內存分配
  
 Simple-React 0.95 發布，Java 并發流庫
                         
                    
                    

                        
相關文檔
                        

 
  Java多線程與并發編程總結
  
  Java IO 流學習總結
  
  java中set map table list~~的總結
  
  WAP 學習總結
  
  Ecside技術學習總結
  
  Hadoop 學習總結
  
  Go 學習筆記
  
  Go 學習筆記 第四版
  
  Go 學習筆記 第三版