Android Thread线程

ゝ一世哀愁。 2022-08-01 15:35 171阅读 0赞

相信大家对线程肯定不陌生，我们在编程的过程中经常要用到线程，Android提供了多线程支持，在Android程序中，VM采用抢占式调度模式对线程进行调度（基于线程优先级来决定CPU的使用权），android一个重要的机制就是线程+消息。

#### 一，线程进程 ####

既然说到线程，得先说说进程。一般来说一个android程序对于一个进程（组件元素activity、service、receiver、provider。都有一个process属性可以指定组件运行在哪个进程中，你可以在清单文件中manifest设置组件的进程）所有的组件都在特定进程的主线程中实例化。  
       线程：线程是属于进程的。同一个进程下的可以有多个线程。这些线程是共同享该进程占有的资源和地址空间的。线程是进程的一部分，一个没有线程的进程可以看做是单线程的。对于android应用来说，当一个应用启动的时候，系统会默认为它创建一个线程，称为“主线程”（UI线程）。这个线程很重要因为它负责处理调度事件到相关的 user interface widgets，包括绘制事件。你的应用也是在这个线程里面与来自Android UI toolkit (包括来自 android.widget 和 android.view 包的组件)的组件进行交互。因此，这个主线程有时候也被称为 UI 线程。  
进程线程总结：  
1. 进程让操作系统的并发性成为可能，而线程让进程的内部并发成为可能。  
2. 进程是操作系统进行资源分配的基本单位。  
3. 线程是操作系统进行调度的基本单。  
4. 线程的划分尺度小于进程，线程隶属于某个进程。  
5. 进程是程序的一种动态形式，是CPU、内存等资源占用的基本单位，而线程是不能独立的占有这些资源的。  
6. 进程之间相互独立，通信比较困难，而线程之间共享一块内存区域，通信比较方便。  
7. 进程在执行过程中，包含比较固定的入口、执行顺序和出口，而线程的这些过程会被应用程序所控制。

#### 二，线程的实现（两种方式） ####

两种方法，继承Thread类和实现Runnable接口

*  继承Thread类  
           extends Thread 重写run方法做我们想做的事情，start启动线程。 简单代码如下：

@Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            new CustomerThread("CustomerThread").start();
        }
    
        public class CustomerThread extends Thread { 
    
            public CustomerThread(String threadName) {
                super(threadName);
            }
    
            @Override
            public void run() {
                /** do our things */
            }
        }

*  实现Runnable接口：run方法里面做我们要做的事情。简单代码如下

@Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            SyncRunnable syncRunnable = new SyncRunnable();
            Thread thread = new Thread(syncRunnable, "syncRunnable");
            thread.start();
        }
    
        public class SyncRunnable implements Runnable { 
            @Override
            public void run() {
                synchronized (this) {
                    for (int i = 0; i < 5; i++) {
                        System.out.println(Thread.currentThread().getName() + " synchronizedloop " + i);
                    }
                }
            }
        }

**注：这两种方法的实现中我都有带上线程的名字。顺便说一点，我们用线程的时候最好给线程加上一个名字，这样我们在看log信息的时候能方便的知道是哪个线程打（默认会thread-0, thread-1什么的）。**

#### 三，线程退出 ####

我们在使用线程的时候经常会碰到这种情况，我们的线程是要一直while执行的（如果不是要一直while执行的thread执行完了就会自动销毁）。这个时候当程序退出的时候我们想要这个while线程也去释放资源。主要有三种方式。

*  使用退出标志，使线程正常退出  
    这个最简单了设置标志位。简单代码如下：

private boolean exit = false;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            SyncThread syncRunnable = new SyncThread("syncThread");
            syncRunnable.start();
        }
    
        @Override
        protected void onDestroy() {
            exit = true;
            super.onDestroy();
        }
    
        public class SyncThread extends Thread { 
    
            public SyncThread(String threadName) {
                super(threadName);
            }
    
            @Override
            public void run() {
                while(!exit) {
                    /** do our things */
                }
            }
        }

在onDestroy方法里面退出。exit = true;

*  使用interrupt()方法中断线程 （当调用线程的interrupt()方法时，系统会抛出一个InterruptedException异常）  
    1）先捕获InterruptedException异常之后通过break来跳出循环，简单代码如下。

SyncThread syncRunnable = null;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            syncRunnable = new SyncThread("syncThread");
            syncRunnable.start();
        }
    
        @Override
        protected void onDestroy() {
            if (null != syncRunnable) {
                syncRunnable.interrupt();
            }
            super.onDestroy();
        }
    
        public class SyncThread extends Thread { 
    
            public SyncThread(String threadName) {
                super(threadName);
            }
            @Override
            public void run() {
                while(true) {
                    /** do our things */
                    try {
                        Thread.sleep(5*1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        /** exit the while */
                        break;
                    }
                }
            }
        }

2）使用isInterrupted()判断线程的中断标志来退出循环。简单代码如下

SyncThread syncRunnable = null;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            syncRunnable = new SyncThread("syncThread");
            syncRunnable.start();
        }
    
        @Override
        protected void onDestroy() {
            if (null != syncRunnable) {
                syncRunnable.interrupt();
            }
            super.onDestroy();
        }
    
        public class SyncThread extends Thread { 
    
            public SyncThread(String threadName) {
                super(threadName);
            }
            @Override
            public void run() {
                while(!isInterrupted()) {
                    /** do our things */
                }
            }
        }

3）两者结合使用（推荐） 在线程未进入阻塞的代码段时通过isInterrupted()判断中断来退出循环，在进入阻塞状态后通过通过捕获中断异常来退出循环，简单代码如下

SyncThread syncRunnable = null;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            syncRunnable = new SyncThread("syncThread");
            syncRunnable.start();
        }
    
        @Override
        protected void onDestroy() {
            if (null != syncRunnable) {
                syncRunnable.interrupt();
            }
            super.onDestroy();
        }
    
        public class SyncThread extends Thread { 
    
            public SyncThread(String threadName) {
                super(threadName);
            }
            @Override
            public void run() {
                while(!isInterrupted()) {
                    /** do our things */
                    try{
                        Thread.sleep(5*1000);
                    }catch(InterruptedException e){
                        e.printStackTrace();
                        break;
                    }
                }
            }
        }

*  使用stop方法强行终止线程（不推荐使用，可能发生不可预料的结果）  
    thread.stop() 不安全主要是：thread.stop()调用之后，创建子线程的线程就会抛出ThreadDeatherror的错误，并且会释放子线程所持有的所有锁。一般任何进行加锁的代码块，都是为了保护数据的一致性，如果在调用thread.stop()后导致了该线程所持有的所有锁的突然释放(不可控制)，那么被保护数据就有可能呈现不一致性，其他线程在使用这些被破坏的数据时，有可能导致一些很奇怪的应用程序错误。

#### 四，多线程通信 ####

*  管道（pipe）属于linux范畴：一条“管道”为两个线程建立一个单向的通道。生产者负责写数据，消费者负责读取数据。简单代码如下

private PipedReader mRead;
        private PipedWriter mWrite;
        private Thread mThread;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            initData();
            try {
                mWrite.write("pipe");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        @Override
        protected void onDestroy() {
            super.onDestroy();
            mThread.interrupt();
            try {
                mRead.close();
                mWrite.close();
            } catch (IOException e) {
            }
        }
    
        private void initData() {
            mRead = new PipedReader();
            mWrite = new PipedWriter();
            try {
                mWrite.connect(mRead);
            } catch (IOException e) {
                e.printStackTrace();
            }
    
            mThread = new Thread(new ThreadPipe(mRead), "ThreadPipe");
            mThread.start();
        }
    
        private static class ThreadPipe implements Runnable { 
            private final PipedReader reader;
            public ThreadPipe(PipedReader reader){
                this.reader = reader;
            }
            @Override
            public void run() {
                while(!Thread.currentThread().isInterrupted()){
                    try {
                        int i;
                        while((i = reader.read()) != -1){
                            char c = (char) i;
                            Log.d("vae_tag", "char = " + c);
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

先把PipedReader，PipedWriter关联起来。如mWrite.connect(mRead);然后这里是在UI线程里面写，ThreadPipe 线程里面读log出来。

*  共享内存：一个变量可以同时被多个线程所访问。这里要特别注意同步和原子操作的问题，这也共享内存容易出错的原因所在，容易出现死锁等。
 *  socket：这个应该简单。
 *  消息队列（Hander和Message）：这个也是android常用的线程间通信方式，网上也有好多关于这个的博文。主要要理清Thread, Handler，Message，Looper，MessageQueue 之间的关系。  
    
    
     *  Looper:(相当于隧道) 一个线程可以产生一个Looper 对象，Looper负责的就是创建管理一个MessageQueue。
     *  MessageQueue（消息队列）：里面放的就是Message对象，每一个线程最多只可以拥有一个MessageQueue，通常使用一个Looper对象对该线程的MessageQueue进行管理，每一个MessageQueue都不能脱离Looper而存在。主线程创建时会默认创建MessageQueue，其他的线程不会默认创建。
     *  Message（消息）：被放入在MessageQueue中。
     *  Handler（消息的处理者）：Handler负责将需要传递的信息封装成Message，通过调用Handler对象的obtainMessage()来实现，将消息传递给Looper，这是通过Handler对象的sendMessage()来实现的。继而由Looper将Message放入MessageQueue中。当Looper对象看到MessageQueue中含有Message，就将其广播出去。该Handler对象收到该消息后，调用相应的Handler对象的handleMessage()方法对其进行处理。简单来说就是当要发送Message消息的时候Handler告诉对应Thread的Looper有消息到来，Looper把Message放入到MessageQueue当中去。当MessageQueue中有Message的时候该Thread的Looper告诉对应的Thread的Handler来处理消息。  
        几个简单例子代码。  
        1）UI线程给自己发送消息。

private Handler handler;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            handler = new HandlerTest(getMainLooper());
            Message msg = handler.obtainMessage(1, 1, 1, "UI thread send message");
            handler.sendMessage(msg);
        }
    
        class HandlerTest extends Handler { 
    
            public HandlerTest(Looper looper) {
                super(looper);
            }
    
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                Log.d("vae_tag", (String)msg.obj);
            }
        }

2）UI线程给其他线程发送消息。

private Button  mButton;
        private Handler handler;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            mButton = (Button) findViewById(R.id.send_message_id);
            new ChildThread("ChildThread").start();
            mButton.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    handler.obtainMessage(1, "UI thread send to child thread").sendToTarget();
                }
            });
        }
    
        class ChildThread extends Thread { 
    
            public ChildThread(String threadName) {
                super(threadName);
            }
    
            public void run() {
                Looper.prepare();/** init Looper */
                handler = new ThreadHandler(Looper.myLooper());
                Looper.loop(); /** start Looper */
            }
    
            class ThreadHandler extends Handler { 
    
                public ThreadHandler(Looper looper) {
                    super(looper);
                }
    
                public void handleMessage(Message msg) {
                    Log.d("vae_tag", "child thread receive the message :" + msg.obj);
                }
            }
        }

3）其他线程给UI线程发送消息。

private Handler handler;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            new ChildThread("ChildThread").start();
        }
    
        class HandlerTest extends Handler { 
    
            public HandlerTest(Looper looper) {
                super(looper);
            }
    
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                Log.d("vae_tag", (String) msg.obj);
            }
        }
    
        class ChildThread extends Thread { 
    
            public ChildThread(String threadName) {
                super(threadName);
            }
            public void run() {
                handler = new HandlerTest(Looper.getMainLooper());
                Message msg = handler.obtainMessage(1, 1, 1, "child thread send the message");
    
                handler.sendMessage(msg);
            }
        }

4）其他线程给其他线程发

private Handler handler;
        private Button mButton;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            mButton = (Button) findViewById(R.id.send_message_id);
            mButton.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    new ChildThread2("ChildThread2").start();
                }
            });
            new ChildThread1("ChildThread1").start();
    
        }
    
        class ChildThread1 extends Thread { 
    
            public ChildThread1(String threadName) {
                super(threadName);
            }
    
            public void run() {
                Looper.prepare();/** init Looper */
                handler = new ThreadHandler(Looper.myLooper());
                Looper.loop(); /** start Looper */
            }
    
            class ThreadHandler extends Handler { 
    
                public ThreadHandler(Looper looper) {
                    super(looper);
                }
    
                public void handleMessage(Message msg) {
                    Log.d("vae_tag", "receive message: " + msg.obj);
                }
            }
        }
    
        class ChildThread2 extends Thread { 
    
            public ChildThread2(String threadName) {
                super(threadName);
            }
    
            public void run() {
                Message msg = handler.obtainMessage(1, 1, 1, "child thread send the message");
                handler.sendMessage(msg);
            }
        }

代码都是非常简单的代码，主要抓住Handler往哪个线程发就绑定到对应线程的Looper。  
**注：关于Message对象，虽然我们可以自己创建一个新的Message，但是更加推荐的是调用handler的obtainMessage方法来获取一个Message对象。这个方法的作用是从系统的消息池中取出一个Message，这样就可以避免Message创建和销毁带来的资源浪费了**

#### 五，子线程更新UI的几种方式 ####

*  handler：上面讲过。
 *  Activity.runOnUIThread(Runnable)：简单代码实现。

private Button   mButton;
        private TextView mTextView;
        private Activity mActivity;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            mActivity = this;
            mTextView = (TextView) findViewById(R.id.text_view_id);
            mButton = (Button) findViewById(R.id.send_message_id);
            mButton.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    new Thread(){
                        public void run() {
                            mActivity.runOnUiThread(new Runnable() {
                                @Override
                                public void run() {
                                    mTextView.setText("click ite");
                                }
                            });
                        };
                    }.start();
                }
            });
        }

*  View.Post(Runnable)或者View.PostDelayed(Runnabe,long)或者handler.post(new Runnable()）三个是一个意思实际上是一样的View.Post(Runnable)源码里面会先获取到当前线程的handler，然后再调用post方法（ViewRootImpl.getRunQueue().post(action);）：简单代码如下：

private Button   mButton;
        private TextView mTextView;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            mTextView = (TextView) findViewById(R.id.text_view_id);
            mButton = (Button) findViewById(R.id.send_message_id);
            mButton.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    new ChileThread(mButton).start();
                }
            });
        }
    
        public class ChileThread extends Thread { 
            private Button mButton;
            public ChileThread(Button textView) {
                mButton = textView;
            }
    
            @Override
            public void run() {
                mButton.post(new Runnable() {
                    @Override
                    public void run() {
                        mTextView.setText("click ite");
                    }
                });
            }
        }

在这里不管是mButton.post() 还是mTextView.post()都是可以的只要是继承View的对象就行。  
\- AsyncTask：异步任务，主要是四个重要的方法。

*  onPreExecute：运行在UI线程，主要目的是为后台线程的运行做准备。当他运行完成后，他会调用doInBackground方法。
 *  doInBackground：运行在后台线程，他用来负责运行任务。他拥有参数Params，并且返回Result。在后台线程的运行当中，为了能够更新作业完成的进度，需要在doInbackground方法中调用PublishProgress方法。该方法拥有参数Progress。通过该方法可以更新Progress的数据。然后当调用完PublishProgress方法，他会调用onProgressUpdate方法用于更新进度。
 *  onProgressUpdate：运行在UI线程，主要目的是用来更新UI线程中显示进度的UI控件。他拥有Progress参数。在doInBackground中调用PublishProgress之后，就会自动调onProgressUpdate方法。
 *  onPostExecute：运行在UI线程，当doInBackground方法运行完后，他会调用onPostExecute方法，并传入Result。在onPostExecute方法中，就可以将Result更新到UI控件上。

#### 六，HandlerThread ####

我们都知道Android中Handler的使用，一般都在UI主线程中执行，因此在Handler接收消息后，处理消息时，不能做一些很耗时的操作，否则将出现ANR错误。Android中专门提供了HandlerThread类，来解决该类问题。HandlerThread类是一个线程专门处理Hanlder的消息HandlerThread用于方便的创建一个含有Looper的线程类。Looper用来创建Handler类，实际上就一个Thread，只不过它比普通的Thread多了一个Looper。一般HandlerThread和Handler类配合使用， Handler将消息发往HandlerThread的消息队列， Handler处理消息。这里启动的是一个新线程 虽然不能直接操作UI 但可以通过Message发送消息来进行操作，其实就是把Handler里面要做的比较耗时的操作放到HandlerThread里面去做，如果有必要的话HandlerThread处理完之后可以再发回给UI线程。  
使用HandlerThread的好处：  
1. 开发中如果多次使用类似new Thread()\{…\}.start()这种方式开启一个子线程，会创建多个匿名线程，使得程序运行起来越来越慢，而HandlerThread自带Looper使他可以通过消息来多次重复使用当前线程，节省开支。  
2. android系统提供的Handler类内部的Looper默认绑定的是UI线程的消息队列，对于非UI线程又想使用消息机制，那么HandlerThread内部的Looper是最合适的，它不会干扰或阻塞UI线程。  
简单的实例代码如下：

public class MainActivity extends ActionBarActivity { 
    
        private Handler         mHandler;
        private MyHandlerThread mHandlerThread;
        private Button          mButton;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            mHandlerThread = new MyHandlerThread("MyHandlerThread");
            mHandlerThread.start();
            mHandler = new Handler(mHandlerThread.getLooper(), mHandlerThread);
            mButton = (Button) findViewById(R.id.send_message_id);
            mButton.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    mHandler.sendEmptyMessage(1);
                }
            });
        }
    
        @Override
        protected void onDestroy() {
            super.onDestroy();
            mHandlerThread.quit();
        }
    
        public class MyHandlerThread extends HandlerThread implements Handler.Callback { 
    
            public MyHandlerThread(String name) {
                super(name);
            }
    
            @Override
            public boolean handleMessage(Message msg) {
                Log.d("vae_tag", "get message");
                return true;
            }
        }
    }

#### 七，线程池 ####

对应数据库连接我们有数据库连接池，对于线程我们也有线程池。线程池是预先创建线程的一种技术。线程池在任务还没到来之前先创建一定数量的线程，放入空闲队列中。这些线程都是处于睡眠状态，即均为启动，不消耗CPU，而只是占用较小的内存空间。当请求到来之后，缓冲池给这次请求分配一个空闲线程，把请求传入此线程中运行，进行处理。当预先创建的线程都处于运行状态，即预制线程不够，线程池可以自由创建一定数量的新线程，用于处理更多的请求。当系统比较闲的时候，也可以通过移除一部分一直处于停用状态的线程。从而达到减少了创建和销毁线程的次数，最大程度的复用对象。

包括三种单一线程池，固定线程池，缓存的线程池使用其他也非常的简单。  
下面是固定线程池的简单实例，很简单的例子。

private Button          mButton;
        private ExecutorService mExecutorService;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            /** create three threads in the pool */
            mExecutorService = Executors.newFixedThreadPool(3);
            mExecutorService.submit(new ChileThread("ChileThread"));
            mButton = (Button) findViewById(R.id.send_message_id);
            mButton.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    mExecutorService.submit(new ChileThread("ChileThread"));
                }
            });
        }
    
        public class ChileThread extends Thread { 
            public ChileThread(String threadName) {
                super(threadName);
            }
            @Override
            public void run() {
                Log.d("vae_tag", "aaaaaaaaaaaaaaaaa");
            }
        }

缓存的线程池 线程池的大小会根据执行的任务数动态分配

mExecutorService = Executors.newCachedThreadPool();

单一线程池

mExecutorService = Executors.newSingleThreadExecutor();

#### 八，Callable，Future ####

Callable 源码

public interface Callable<V> {
        /** * Computes a result, or throws an exception if unable to do so. * * @return computed result * @throws Exception if unable to compute a result */
        V call() throws Exception;
    }

Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其他线程执行的任务。Callable是一个泛型接口。call()函数返回的类型就是传递进来的V类型，Callable要配合ExecutorService来使用，采用ExecutorService的submit方法提交。  
Callable 和 Runnable方法的区别：  
1）Callable定义的方法是call，而Runnable定义的方法是run。  
2）Callable的call方法可以有返回值，而Runnable的run方法不能有返回值。  
3）Callable的call方法可抛出异常，而Runnable的run方法不能抛出异常。

Future表示异步计算的结果，它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。Future的cancel方法可以取消任务的执行，它有一布尔参数，参数为 true 表示立即中断任务的执行，参数为 false 表示允许正在运行的任务运行完成。Future的 get 方法等待计算完成，获取计算结果。简单的实例代码如下。  
1. 单个任务：

public class MainActivity extends ActionBarActivity { 
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            signalTaskTest();
            Log.d("vae_tag", "after signalTaskTest function");
        }
    
        private void signalTaskTest() {
            Task.callInBackground(new Callable<Void>() {
                @Override
                public Void call() throws Exception {
                    /** start test */
                    ExecutorService threadPool = Executors.newSingleThreadExecutor();
                    Future<String> future = threadPool.submit(new Callable<String>() {
                        public String call() throws Exception {
                            Thread.sleep(2000);
                            return "hello";
                        }
                    });
                    Log.d("vae_tag", "start waiting result");
                    try {
                        Log.d("vae_tag", "get the result " + future.get());
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (ExecutionException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    return null;
                }
            });
        }
    }

**注：我是在一个线程里面测试 future.get()会等待获取结果（这里有用到Task.callInBackground 在gradle用引入compile ‘com.parse.bolts:bolts-android:1.2.0’）**  
2. 多个任务：

public class MainActivity extends ActionBarActivity { 
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            multipleTasksTest();
        }
    
        private void multipleTasksTest() {
            Task.callInBackground(new Callable<Void>() {
                @Override
                public Void call() throws Exception {
                    /** start test */
                    ExecutorService threadPool2 = Executors.newFixedThreadPool(10);
                    CompletionService<Integer> compeletionService = new ExecutorCompletionService<Integer>(
                        threadPool2);
                    for (int i = 0; i <= 10; i++) {
                        final int seq = i;
                        compeletionService.submit(new Callable<Integer>() {
                            @Override
                            public Integer call() throws Exception {
                                Thread.sleep(new Random().nextInt(5000));
                                return seq;
                            }
                        });
                    }
                    for (int i = 0; i < 10; i++) {
                        try {
                            Log.d("vae_tag", "result = " + compeletionService.take().get());
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        } catch (ExecutionException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                    return null;
                }
            });
        }
    }

配合CompletionService使用。

#### 九，推荐（EventBus 一个可以用于通信的开源库） ####

[github项目地址 https://github.com/greenrobot/EventBus][github_ https_github.com_greenrobot_EventBus]

这个也是我们在应用中经常用到的用于通信的一个类库。特别是在fragment 和fragment，fragment和activity等等之间通信非常的方便，用起来也非常的简单具体的可以去google下。

[github_ https_github.com_greenrobot_EventBus]: https://github.com/greenrobot/EventBus