走進Java Android 的線程世界

直奔主題

首先我們來看看Java的線程通訊基礎

    //產品
    static class ProductObject{
        //線程操作變量可見
        public volatile static String value;
    }

    //生產者線程
    static class Producer extends Thread{
        Object lock;

        public Producer(Object lock) {
            this.lock = lock;
        }

        @Override
        public void run() {
            //不斷生產產品
            while(true){
                synchronized (lock) { //互斥鎖
                    //產品還沒有被消費，等待
                    if(ProductObject.value != null){
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    //產品已經消費完成，生產新的產品
                    ProductObject.value = "NO:"+System.currentTimeMillis();
                    Log.i(TAG,"生產產品："+ProductObject.value);
                    lock.notify(); //生產完成，通知消費者消費
                }
            }

        }
    }

    //消費者線程
    static class Consumer extends Thread{
        Object lock;
        public Consumer(Object lock) {
            this.lock = lock;
        }

        @Override
        public void run() {
            while(true){
                synchronized (lock) {
                    //沒有產品可以消費
                    if(ProductObject.value == null){
                        //等待，阻塞
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    Log.i(TAG,"消費產品："+ProductObject.value);
                    ProductObject.value = null;
                    lock.notify(); //消費完成，通知生產者，繼續生產
                }
            }
        }
    }

調用:

        Object lock = new Object();
        new Producer(lock).start();
        new Consumer(lock).start();

Log:

這是一些簡單的線程通訊基礎，兩個線程進行交互的用法。

接下來分析一下 Java中的FutureTask

我們先來看看類圖

再看看怎麼用的

    //異步任務
    static class Task implements Callable<Integer> {
        //返回異步任務的執行結果
        @Override
        public Integer call() throws Exception {
            int i = 0;
            for (; i < 10; i++) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Log.i(TAG, Thread.currentThread().getName() + "_" + i);
            }
            return i;
        }
    }

初始化執行

        Task work = new Task();
        FutureTask<Integer> future = new FutureTask<Integer>(work) {
            //異步任務執行完成，回調
            @Override
            protected void done() {
                try {
                    Log.i(TAG, "done:" + get());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (ExecutionException e) {
                    e.printStackTrace();
                }
            }
        };
        //線程池（使用了預定義的配置）
        ExecutorService executor = Executors.newCachedThreadPool();
        executor.execute(future);

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        //取消異步任務
//        future.cancel(true);
        try {
            //阻塞，等待異步任務執行完畢
            Log.i(TAG, "" + future.get());

        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

Log：

從上面代碼可以看出
這個FutureTask 解決異步任務執行的結果，主線程無法輕易的獲取
這是怎麼做到的呢–>我們就需要翻越FutureTask的代碼

Future

package java.util.concurrent;

public interface Future<V> {

    boolean cancel(boolean mayInterruptIfRunning);

    boolean isCancelled();

    boolean isDone();

    V get() throws InterruptedException, ExecutionException;

    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

Runnable

package java.lang;

public interface Runnable {
    public abstract void run();
}

RunnableFuture

package java.util.concurrent;

public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

FutureTask

package java.util.concurrent;

import java.util.concurrent.locks.LockSupport;

public class FutureTask<V> implements RunnableFuture<V> {
    ......以下只截取部分代碼
    /** The underlying callable; nulled out after running */
    private Callable<V> callable;

    /** The thread running the callable; CASed during run() */
    private volatile Thread runner;

    public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }

    public boolean cancel(boolean mayInterruptIfRunning) {
        if (!(state == NEW &&
              U.compareAndSwapInt(this, STATE, NEW,
                  mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
            return false;
        try {    // in case call to interrupt throws exception
            if (mayInterruptIfRunning) {
                try {
                    Thread t = runner;
                    if (t != null)
                        t.interrupt();
                } finally { // final state
                    U.putOrderedInt(this, STATE, INTERRUPTED);
                }
            }
        } finally {
            finishCompletion();
        }
        return true;
    }

    /**
     * @throws CancellationException {@inheritDoc}
     */
    public V get() throws InterruptedException, ExecutionException {
        int s = state;
        if (s <= COMPLETING)
            s = awaitDone(false, 0L);
        return report(s);
    }




    protected void done() { }


    protected void set(V v) {
        if (U.compareAndSwapInt(this, STATE, NEW, COMPLETING)) {
            outcome = v;
            U.putOrderedInt(this, STATE, NORMAL); // final state
            finishCompletion();
        }
    }


    protected void setException(Throwable t) {
        if (U.compareAndSwapInt(this, STATE, NEW, COMPLETING)) {
            outcome = t;
            U.putOrderedInt(this, STATE, EXCEPTIONAL); // final state
            finishCompletion();
        }
    }

    public void run() {
        if (state != NEW ||
            !U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }


    private void finishCompletion() {
        // assert state > COMPLETING;
        for (WaitNode q; (q = waiters) != null;) {
            if (U.compareAndSwapObject(this, WAITERS, q, null)) {
                for (;;) {
                    Thread t = q.thread;
                    if (t != null) {
                        q.thread = null;
                        LockSupport.unpark(t);
                    }
                    WaitNode next = q.next;
                    if (next == null)
                        break;
                    q.next = null; // unlink to help gc
                    q = next;
                }
                break;
            }
        }

        done();

        callable = null;        // to reduce footprint
    }
    ......以上只截取部分代碼
}

從上面代碼可以看出
Java FutureTask 異步任務操作提供了便利性
1.獲取異步任務的返回值–> V get()
2.監聽異步任務的執行完畢–>finishCompletion()–>done()
3.取消異步任務–>cancel(boolean mayInterruptIfRunning)

從上面的例子，我們可以看到Executors去調用這個Future那麼這個Executors又是啥玩意呢？！

像剛纔看Future那樣我們點進去看看這個Executors我們可以發現很多東西，然而，其實這個就是鼎鼎大名的 線程池 ！
我們還是先看看類圖

因爲實現類方法太多了，還是直接看api文檔比較好。

一個任務

    static class MyTask implements Runnable {

        int i;

        public MyTask(int i) {
            this.i = i;
        }

        @Override
        public void run() {
            Log.i(TAG, Thread.currentThread().getName() + ";i:" + i);
        }

    }

初始化–>運行線程池

        int CPU_COUNT = Runtime.getRuntime().availableProcessors();  //可用的CPU個數
        Log.i(TAG, "CPU_COUNT-->" + CPU_COUNT);
        int CORE_POOL_SIZE = CPU_COUNT + 1; //5(corePoolSize - 池中所保存的線程數，包括空閒線程。)
        Log.i(TAG, "CORE_POOL_SIZE-->" + CORE_POOL_SIZE);
        int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1; //9(maximumPoolSize - 池中允許的最大線程數。)
        Log.i(TAG, "MAXIMUM_POOL_SIZE-->" + MAXIMUM_POOL_SIZE);

        int KEEP_ALIVE = 1;//(keepAliveTime - 當線程數大於核心時，此爲終止前多餘的空閒線程等待新任務的最長時間。)

        //任務隊列（128）(workQueue - 執行前用於保持任務的隊列。此隊列僅由保持 execute 方法提交的 Runnable 任務。)
        final BlockingQueue<Runnable> sPoolWorkQueue = new LinkedBlockingQueue<Runnable>(128);

        //線程工廠(threadFactory - 執行程序創建新線程時使用的工廠。)
        ThreadFactory sThreadFactory = new ThreadFactory() {
            private final AtomicInteger mCount = new AtomicInteger(1);

            public Thread newThread(Runnable r) {
                String name = "Thread #" + mCount.getAndIncrement();
                Log.i(TAG, "newThread-->" + name);
                return new Thread(r, name);
            }
        };

        //線程池
        Executor THREAD_POOL_EXECUTOR = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
                //(unit - keepAliveTime 參數的時間單位。)
                TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);


        /*  如果運行的線程少於 corePoolSize，則 Executor 始終首選添加新的線程，而不進行排隊。
            如果運行的線程等於或多於 corePoolSize，則 Executor 始終首選將請求加入隊列，而不添加新的線程。
            如果無法將請求加入隊列，則創建新的線程，除非創建此線程超出 maximumPoolSize，在這種情況下，任務將被拒絕。*/
        //執行異步任務
        //如果當前線程池中的數量大於corePoolSize，緩衝隊列workQueue已滿，
        //並且線程池中的數量等於maximumPoolSize，新提交任務由Handler處理。
        //RejectedExecutionException
        for (int i = 0; i < 200; i++) {
            //相當於new AsyncTask().execute();
            THREAD_POOL_EXECUTOR.execute(new MyTask(i));
        }

Log如下

從Log我們可以看出每個任務都有一個線程去完成。

其實這個就是Android中AsyncTask的原理我們不妨分析一下AsyncTask：

初始化

執行

返回

返回UI線程

Progress更新UI

JAVA API 文檔：http://tool.oschina.net/apidocs/apidoc?api=jdk-zh
Android API文檔：http://tool.oschina.net/apidocs/apidoc?api=android/reference
文章代碼：https://github.com/gepriniusce/TongsonPlay/tree/Threah