細數Android開源專案中那些頻繁使用的併發庫中的類

這篇blog旨在幫助大家 梳理一下前面分析的那些開原始碼中喜歡使用的一些類，這對我們真正理解這些專案是有極大好處的，以後遇到類似問題 我們就可以自己模仿他們也寫

出類似的程式碼。

 

1.ExecutorService

這個類實際上就是一個介面

public interface ExecutorService extends Executor {

我們可以看看有哪些頻繁使用的類 是實現了這個介面的，其實主要就是3個。

 /**
     * Creates a thread pool that reuses a fixed number of threads
     * operating off a shared unbounded queue.  At any point, at most
     * {@code nThreads} threads will be active processing tasks.
     * If additional tasks are submitted when all threads are active,
     * they will wait in the queue until a thread is available.
     * If any thread terminates due to a failure during execution
     * prior to shutdown, a new one will take its place if needed to
     * execute subsequent tasks.  The threads in the pool will exist
     * until it is explicitly {@link ExecutorService#shutdown shutdown}.
     *
     * @param nThreads the number of threads in the pool
     * @return the newly created thread pool
     * @throws IllegalArgumentException if {@code nThreads <= 0}
     */
    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

這個執行緒池，就是有固定執行緒數的一個執行緒池，有共享的無界佇列來執行這些執行緒。

 

/**
     * Creates a thread pool that creates new threads as needed, but
     * will reuse previously constructed threads when they are
     * available.  These pools will typically improve the performance
     * of programs that execute many short-lived asynchronous tasks.
     * Calls to {@code execute} will reuse previously constructed
     * threads if available. If no existing thread is available, a new
     * thread will be created and added to the pool. Threads that have
     * not been used for sixty seconds are terminated and removed from
     * the cache. Thus, a pool that remains idle for long enough will
     * not consume any resources. Note that pools with similar
     * properties but different details (for example, timeout parameters)
     * may be created using {@link ThreadPoolExecutor} constructors.
     *
     * @return the newly created thread pool
     */
    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

這個執行緒池，是根據需要來建立這些執行緒的，但是以前構造過的執行緒 必要時可以重用他們，所以這個在很多android的開源專案裡都有用到，很頻繁，對於執行很多短期的非同步任務來說，這個執行緒池可以極大的提高程式的效能。

 

/**
     * Creates an Executor that uses a single worker thread operating
     * off an unbounded queue. (Note however that if this single
     * thread terminates due to a failure during execution prior to
     * shutdown, a new one will take its place if needed to execute
     * subsequent tasks.)  Tasks are guaranteed to execute
     * sequentially, and no more than one task will be active at any
     * given time. Unlike the otherwise equivalent
     * {@code newFixedThreadPool(1)} the returned executor is
     * guaranteed not to be reconfigurable to use additional threads.
     *
     * @return the newly created single-threaded Executor
     */
    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

而這個執行緒池就比較特殊一點，他只有一個worker執行緒在工作。

 

來看第一個程式：

public class Test1 {

    public static void main(String[] args) {
        ExecutorService exectrorService = Executors.newFixedThreadPool(10);
        // execute非同步的方法去執行這個runnable 但是這種方法無法取得執行之後的返回值
        exectrorService.execute(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                int i = 0;
                while (true) {
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println(i);
                    i++;
                }
            }

        });

        exectrorService.execute(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                int i = 100;
                while (true) {
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println(i);
                    i++;
                }
            }

        });

很簡單 沒有什麼好說的只是為了演示一下這個方法，繼續往下看：

public class Test1 {

    public static void main(String[] args) {
        ExecutorService exectrorService = Executors.newFixedThreadPool(10);
        Future future = exectrorService.submit(new Runnable() {

            @Override
            public void run() {
                System.out.println("thread start");
                // TODO Auto-generated method stub
                try {
                    Thread.sleep(13000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println("task done");
            }
        });
        System.out.println("ready to print status");
        try {
            // 執行完畢以後才會返回null,如果執行緒還沒有執行完畢 那這個地方會阻塞
            System.out.println("future.get ==" + future.get());
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ExecutionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("finish ready");

這個就是為了演示get方法是個阻塞方法的 我們可以看下列印的日誌。

程式一開始執行 日誌如下：

thread start
ready to print status

當執行緒執行完畢大約過了13秒以後

才會繼續輸入日誌如下：

task done
future.get ==null
finish ready

繼續看下面的例子：

package com.android.testclass;

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 Test1 {

    public static void main(String[] args) {
        ExecutorService exectrorService = Executors.newFixedThreadPool(10);
        // 這個submit方法則會保證結束以後把結果返回給future，用泛型定義的方法 你可以
        // 用任意的object代替T
        Future future = exectrorService.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                // TODO Auto-generated method stub
                System.out.println("call start");

                Thread.sleep(5000);

                return "call done";
            }
        });
        System.out.println("ready to print");
        try {
            System.out.println("future.get()" + future.get());
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ExecutionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("finish");

    }
}

同樣是submit方法 只不過這次我們換了一個引數 這次是callable引數，這麼做的好處就是執行完畢以後可以拿到結果了

一開始輸出：

call start
ready to print

執行緒執行完畢以後輸出：

future.get()call done
finish

然後我們繼續看invokeany這個函式：

package com.android.testclass;

import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test2 {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        Set<Callable<String>> callables = new HashSet<Callable<String>>();
        callables.add(new Callable<String>() {
            @Override
            public String call() throws Exception {
                // TODO Auto-generated method stub
                System.out.println("task 1 start");
                Thread.sleep(3000);
                return "Task 1";
            }
        });
        callables.add(new Callable<String>() {
            @Override
            public String call() throws Exception {
                System.out.println("task 2 start");
                Thread.sleep(3000);
                return "Task 2";
            }
        });
        callables.add(new Callable<String>() {
            @Override
            public String call() throws Exception {
                System.out.println("task 3 start");
                Thread.sleep(3000);
                return "Task 3";
            }
        });
        System.out.println("ready to print");
        try {
            //返回某一個callable執行結束的結果，結果並不確定
            String result = executorService.invokeAny(callables);
            System.out.println("result==" + result);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ExecutionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("done to print");

    }
}

輸出我就不放了 大家可以自己跑一下。這個函式用的比較少。

 

那下面這個invokeall函式用的就比較多了

package com.android.testclass;

import java.util.HashSet;
import java.util.List;
import java.util.Set;
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 Test3 {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        Set<Callable<String>> callables = new HashSet<Callable<String>>();
        callables.add(new Callable<String>() {
            @Override
            public String call() throws Exception {
                // TODO Auto-generated method stub
                System.out.println("task 1 start");
                Thread.sleep(3000);
                return "Task 1";
            }
        });
        callables.add(new Callable<String>() {
            @Override
            public String call() throws Exception {
                System.out.println("task 2 start");
                Thread.sleep(6000);
                return "Task 2";
            }
        });
        callables.add(new Callable<String>() {
            @Override
            public String call() throws Exception {
                System.out.println("task 3 start");
                Thread.sleep(9000);
                return "Task 3";
            }
        });
        System.out.println("ready to print");

        try {
            // invoke方法也是阻塞方法，一定是所有callable都執行完畢才會返回結果
            List<Future<String>> futures = executorService.invokeAll(callables);
            System.out.println("invoke done");
            for (Future<String> future : futures) {
                System.out.println("future.get=" + future.get());
                System.out.println("get done");
            }
            System.out.println("all get done");
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ExecutionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

 

總的來說，在android裡如果你要使用執行緒池的話，那上面的這些方法 基本就肯定足夠你使用了。

 

2.ConcurrentHashMap

這個類，相信很多人都不陌生，我就略微提一下，很多人以前在單執行緒的時候使用hashmap，多執行緒的時候使用hashtable，這麼做雖然是對的，

但是hashtable裡的原始碼說明了 這是直接對整個map進行加鎖，效率是很低的，而這個concurrenthashmap的讀操作幾乎不會有鎖，

而寫操作由於採用了分段處理，所以寫操作的鎖 的概率和次數也大大降低。總體來說這是一個效率極高的 可適用於併發性的hashmap。

例子和原理 網上有很多 我這裡就不放了。

此外和他類似的還有LinkedHashMap，實現LRU的最好選擇，這個也不多講，只是提一下，網上資料很多。

 

3.PriorityBlockingQueue

這個就是優先順序佇列，當然也是支援併發的，這個佇列裡存放的物件 必須是實現了Comparable 介面的。並且小的是在這個佇列前面的 大的就一定是在佇列的後面。

比如說我們先定義一個類：

package com.android.testclass;

public class PriorityEntity implements Comparable<PriorityEntity> {

    private static int count = 0;
    private int id = count++;
    private int priority;
    private int index = 0;

    public PriorityEntity(int priority, int index) {
        // TODO Auto-generated constructor stub
        this.priority = priority;
        this.index = index;
    }

    @Override
    public String toString() {
        return "PriorityEntity [id=" + id + ", priority=" + priority + ", index=" + index + "]";
    }

    @Override
    public int compareTo(PriorityEntity o) {
        // TODO Auto-generated method stub
        return this.priority > o.priority ? 1 : this.priority < o.priority ? -1 : 0;
    }

}

那個靜態變數就表示索引的，構造出一個物件 索引就加1. 然後我們來寫一下測試這個佇列的程式碼：

package com.android.testclass;

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.TimeUnit;

public class Test6 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        PriorityBlockingQueue q = new PriorityBlockingQueue<>();
        Random r = new Random(47);
        ExecutorService se = Executors.newCachedThreadPool();
        //往佇列裡 放物件,priority的值是 隨即的
        se.execute(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                int i = 0;
                while (true) {
                    q.put(new PriorityEntity(r.nextInt(10), i++));

                    try {
                        TimeUnit.MILLISECONDS.sleep(r.nextInt(1000));
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }

                }
            }
        });
        //從佇列裡 取物件,然後把佇列裡剩餘的值打出來 就會發現 每次取出來的都是最小的那個 剩下的都是從小到大排序好的
        se.execute(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                while (true) {
                    try {
                        System.out.println(("take-- " + q.take() + " left:-- [" + q.toString() + "]"));
                    } catch (InterruptedException e1) {
                        // TODO Auto-generated catch block
                        e1.printStackTrace();
                    }
                    try {
                        TimeUnit.MILLISECONDS.sleep(r.nextInt(1000));
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }

                }
            }
        });

    }

}

擷取一段日誌 可以得到我們註釋裡的結論：

take-- PriorityEntity  [priority=8, index=0] left:-- [[]]
take-- PriorityEntity  [priority=1, index=1] left:-- [[]]
take-- PriorityEntity  [priority=8, index=2] left:-- [[]]
take-- PriorityEntity  [priority=7, index=3] left:-- [[PriorityEntity  [priority=8, index=4]]]
take-- PriorityEntity  [priority=8, index=4] left:-- [[PriorityEntity  [priority=9, index=5]]]
take-- PriorityEntity  [priority=1, index=6] left:-- [[PriorityEntity  [priority=8, index=7], PriorityEntity  [priority=9, index=5]]]
take-- PriorityEntity  [priority=8, index=7] left:-- [[PriorityEntity  [priority=9, index=5]]]
take-- PriorityEntity  [priority=2, index=8] left:-- [[PriorityEntity  [priority=9, index=5]]]
take-- PriorityEntity  [priority=9, index=5] left:-- [[]]
take-- PriorityEntity  [priority=5, index=9] left:-- [[]]
take-- PriorityEntity  [priority=4, index=10] left:-- [[]]
take-- PriorityEntity  [priority=4, index=13] left:-- [[PriorityEntity  [priority=6, index=11], PriorityEntity  [priority=6, index=12]]]
take-- PriorityEntity  [priority=3, index=14] left:-- [[PriorityEntity  [priority=6, index=16], PriorityEntity  [priority=6, index=12], PriorityEntity  [priority=6, index=11], PriorityEntity  [priority=8, index=15]]]
take-- PriorityEntity  [priority=6, index=16] left:-- [[PriorityEntity  [priority=6, index=12], PriorityEntity  [priority=8, index=15], PriorityEntity  [priority=6, index=11]]]
take-- PriorityEntity  [priority=6, index=12] left:-- [[PriorityEntity  [priority=6, index=17], PriorityEntity  [priority=8, index=15], PriorityEntity  [priority=6, index=11]]]
take-- PriorityEntity  [priority=6, index=17] left:-- [[PriorityEntity  [priority=6, index=11], PriorityEntity  [priority=8, index=15], PriorityEntity  [priority=8, index=18]]]
take-- PriorityEntity  [priority=6, index=11] left:-- [[PriorityEntity  [priority=8, index=18], PriorityEntity  [priority=8, index=15]]]
take-- PriorityEntity  [priority=4, index=19] left:-- [[PriorityEntity  [priority=8, index=18], PriorityEntity  [priority=8, index=15]]]
take-- PriorityEntity  [priority=8, index=18] left:-- [[PriorityEntity  [priority=8, index=15]]]
take-- PriorityEntity  [priority=7, index=20] left:-- [[PriorityEntity  [priority=8, index=15]]]
take-- PriorityEntity  [priority=2, index=21] left:-- [[PriorityEntity  [priority=4, index=22], PriorityEntity  [priority=8, index=15]]]
take-- PriorityEntity  [priority=4, index=22] left:-- [[PriorityEntity  [priority=8, index=23], PriorityEntity  [priority=8, index=15]]]
take-- PriorityEntity  [priority=8, index=23] left:-- [[PriorityEntity  [priority=8, index=15]]]
take-- PriorityEntity  [priority=5, index=24] left:-- [[PriorityEntity  [priority=8, index=15]]]
take-- PriorityEntity  [priority=2, index=25] left:-- [[PriorityEntity  [priority=8, index=26], PriorityEntity  [priority=8, index=15]]]
take-- PriorityEntity  [priority=3, index=27] left:-- [[PriorityEntity  [priority=4, index=28], PriorityEntity  [priority=8, index=15], PriorityEntity  [priority=8, index=26]]]
take-- PriorityEntity  [priority=1, index=30] left:-- [[PriorityEntity  [priority=4, index=28], PriorityEntity  [priority=7, index=29], PriorityEntity  [priority=8, index=26], PriorityEntity  [priority=8, index=15], PriorityEntity  [priority=8, index=31]]]
take-- PriorityEntity  [priority=4, index=28] left:-- [[PriorityEntity  [priority=7, index=29], PriorityEntity  [priority=8, index=15], PriorityEntity  [priority=8, index=26], PriorityEntity  [priority=9, index=32], PriorityEntity  [priority=8, index=31]]]

有興趣的話可以看看java裡面 有幾種類 都實現了AbstractQueue,可以挑選出適合自己業務裡的佇列，減少開發難度

public abstract class AbstractQueue<E>
    extends AbstractCollection<E>
    implements Queue<E> {

 

4.CopyOnWriteArrayList

考慮這樣一種場景，一個list，被好幾個執行緒同時讀寫，那一般都會報錯。

Exception in thread "pool-1-thread-7" java.util.ConcurrentModificationException
    at java.util.ArrayList$Itr.checkForComodification(Unknown Source)
    at java.util.ArrayList$Itr.next(Unknown Source)
    at com.android.testclass.Test7$ReadTask.run(Test7.java:35)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)
    at java.lang.Thread.run(Unknown Source)
Exception in thread "pool-1-thread-6" java.util.ConcurrentModificationException
    at java.util.ArrayList$Itr.checkForComodification(Unknown Source)
    at java.util.ArrayList$Itr.next(Unknown Source)
    at com.android.testclass.Test7$ReadTask.run(Test7.java:35)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)
    at java.lang.Thread.run(Unknown Source)

於是很多人就喜歡用Collections.synchronizedList() 來處理，但是這樣做在很多時候效率是低的，比如

假設現在告訴你，你需要設計一個快取list，你就應該使用CopyOnWrite這個類了，因為快取大家都知道，讀操作比較多，而寫操作除了在初始建立快取的階段，其他時候很少使用。

他的原理也很簡單，就是你在用迭代器寫操作的時候 是把原來的資料拷貝了一份映象在記憶體中，而你在讀的時候 是讀的本體，寫操作寫完以後才會覆蓋掉原來的本地。所以可以

得知 這個類對於頻繁讀的同步性list 是非常有效的。使用方法也很簡單。

        List<String> list = new CopyOnWriteArrayList<String>();

 

5.ThreadLocal

這個類也是很有效，很多開源作者喜歡用的一個類，他主要的作用是為每個執行緒創造一個變數的副本互相不會影響。很多人不理解這句話，

對於多執行緒操作來說 分為兩種

1 第一種，執行緒和執行緒之間互相讀取操作，比如全域性的計數器這種，a執行緒要加，b執行緒也要加，每次加的時候 都要讀取最新的計數器的狀態。這是最常見的一種同步操作。

2 第二種，session，session一個使用者一個，互相不影響，大家維持自己的就可以，他的目標就是a的seesion a自己操作 儲存 讀取，b的seesion也是自己維護，和其他人無關。

換一句話說 如果你需要多個執行緒之間通訊，那就用同步機制，

如果你不需要執行緒與執行緒之間通訊，只要互相別影響 不讓他們發生衝突 則threadlocal是最佳選擇。

package com.android.testclass;

public class Test8 {

    static final ThreadLocal<Integer> local = new ThreadLocal<Integer>() {

        protected Integer initialValue() {

            return 0;
        };

    };

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Thread[] threads = new Thread[5];
        for (int i = 0; i < 5; i++) {
            threads[i] = new Thread(new Runnable() {

                @Override
                public void run() {
                    // TODO Auto-generated method stub

                    int num = local.get();
                    for (int i = 0; i < 5; i++) {
                        num++;
                    }
                    local.set(num);
                    System.out.println(Thread.currentThread().getName() + " : " + local.get());

                }
            }, "thread-" + i);
        }

        for (Thread thread : threads) {
            thread.start();
        }

    }

}

看下輸出

thread-0 : 5
thread-4 : 5
thread-1 : 5
thread-3 : 5
thread-2 : 5

 

接著看下面的

package com.android.testclass;

public class Test9 {

    private static Index num = new Index();
    // 建立一個Index型別的本地變數
    private static ThreadLocal<Index> local = new ThreadLocal<Index>() {
        @Override
        protected Index initialValue() {
            return num;
        }
    };

    public static void main(String[] args) throws InterruptedException {
        Thread[] threads = new Thread[5];
        for (int j = 0; j < 5; j++) {
            threads[j] = new Thread(new Runnable() {
                @Override
                public void run() {
                    // 取出當前執行緒的本地變數，並累加1000次
                    Index index = local.get();
                    for (int i = 0; i < 1000; i++) {
                        index.increase();
                    }
                    System.out.println(Thread.currentThread().getName() + " : " + index.num);

                }
            }, "Thread-" + j);
        }
        for (Thread thread : threads) {
            thread.start();
        }
    }

    static class Index {
        int num;

        public void increase() {
            num++;
        }
    }

}

看輸出

Thread-1 : 2594
Thread-4 : 3594
Thread-2 : 2594
Thread-0 : 2594
Thread-3 : 4594

是因為第10行，那邊放的是一個靜態變數的引用，所以輸出的結果不是我們想象的

其實只要改成

 

private static ThreadLocal<Index> local = new ThreadLocal<Index>() {
        @Override
        protected Index initialValue() {
            return new Index();
        }
    };

結果就是正確的：

Thread-2 : 1000
Thread-3 : 1000
Thread-0 : 1000
Thread-4 : 1000
Thread-1 : 1000