Android多线程编程

Android多线程编程

在进行Android界面操作时经常会遇到ANR等直接在子线程更新界面的错误，需要在ui线程中更新或者将耗时的逻辑放到子线程中更新，执行完返回结果即可。
在Android中，从Ui角度，可分为Ui线程和非Ui线程，Android一启动便创建了一个主线程，该线程即Ui线程，用于更新界面，这意味着所有耗时的动作如果在这个Ui线程中执行将造成界面卡顿现象，不时Android将退出程序。为了更好的交互效果，需要将耗时的动作放到新建的子线程中，有时为了更好的管理线程达到较好的运行效率，使用线程池进行管理。下面从Android创建线程的几种方式，更新Ui的方法和线程池三个角度介绍如何使用Android多线程，深入的运行原理可以查看Android官方文档和底层代码。
Android线程的创建有以下几种方式：
1、使用Thread：使用Thread来创建一个线程或者继承Thread再创建线程，如下通过继承Thread创建线程，1秒钟来更新一次TextView，打印1至12的数字。

package com.example.multithreadtest;

import android.app.Activity;
import android.content.Context;
import android.widget.TextView;

/**
 * 使用继承Thread启动一个线程
 */

public class myThread extends Thread {
    MainActivity context;
    private int count=0;
    myThread(MainActivity context){
        this.context = context;
        }
    @Override
    public void run() {
        super.run();
        while (true)
        {
            context.updateUi(count+"",false);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            count++;
            if (count>12){
                context.updateUi("i am wake hahahahaha",false);
                break;
            }
        }
    }
}

在MainActivity中的调用方式：

 myThread myTh = new myThread(this);
 myTh.start();

效果：

2、实现Runable接口创建线程：

 public void runnableThreadTest(){
        new Thread(new Runnable() {
            @Override
            public void run() {
            //实现逻辑
            }
        }).start();
    }

3、使用Callable和Future创建线程（Java）
从 Java 5 开始，Java提供了Callable接口，该接口像是Runnable接口的加强版，Callable接口提供了一个call()方法，可以作为线程的执行体，且call()方法比run()方法功能更强大：有返回值、抛出异常、任务取消、查询是否完成、获取结果。
Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。主要接口有：
isCancelled方法表示任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true。
isDone方法表示任务是否已经完成，若任务完成，则返回true；
get()方法用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回；
get(long timeout, TimeUnit unit)用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回null。
下面通过继承Callable接口来创建线程，并调用Future的方法来操作线程任务

package com.example.multithreadtest;

import android.provider.ContactsContract;

import java.util.concurrent.Callable;

/**
 * Created by new on 2017/7/27.
 */

public class CallableTest implements Callable{

    MainActivity listener;
    private int count = 0;

    public CallableTest(MainActivity obj){
        listener = obj;
    }

    @Override
    public Object call() throws Exception {

        while (true)
        {
            Thread.sleep(1000);
            count++;
            listener.updateUi(count+"",true);
            if (count > 10)
                break;
        }

        return "Callable return String";
    }
}

MainActivity调用方式：

CallableTest call = new CallableTest(this);
task = new FutureTask<String>(call);
CallThread = new Thread(task);
CallThread.start();

可通过调用cancel来取消任务：按下按钮停止。

  @OnClick(R.id.cancelB)
    public void OnClick(View view)
    {
        if (!task.isCancelled())
            if (task.cancel(true))
                updateUi("cancel success",false);
    }

也可调用get()或者有超时返回的方法：get(long timeout, TimeUnit unit)等待返回结果：

 //updateUi("thread return : "+task.get(),true );或者
 if (!task.isCancelled())
    updateUi("thread return : "+task.get(2, TimeUnit.SECONDS),true);

需要注意的是次函数不能在主函数中调用，否则会使Ui卡顿甚至退出程序。
效果如下：

Android更新Ui线程的方法：
Android的Ui线程为不安全线程，直接在子线程中更新Ui可能会使得程序崩掉，需要在Ui线程中更新Ui。Android提供了以下几种更新Ui界面的方法：
1、使用Handler更新Ui（Looper、Handler与Thread使用）： 说到Handler，得先了解一下Looper。Android有一个消息队列管理器，这个管理器就是Looper，它用来管理一条线程中的消息队列，该线程会不断的从消息队列中取出消息来执行处理。Looper负责消息的调度与循环，而MessageQueue就是这条消息队列，每个Looper都有一个MessageQueue，消息是Massage，负责消息的封装，而handler负责将Massage发送到这条队列中，它的关系可以用如下图表示：

Android应用在启动的时候只有在主线程即Ui线程分配了Looper，其他子线程若想使用Looper需要调用Looper.prepare来创建一个消息队列管理，最后调用loop来循环调用队列中的消息来执行直到线程退出。所以在主线程中，可以直接使用Handler发送消息，主线程的Looper接收这个消息后放到消息队列等待调用执行。如下，直接在子线程中利用Handler来更新Ui界面，没有创建一个Looper来管理是因为主线程已经有了这个Looper。

  //在主线程中定义Handler，等待接收消息处理
    Handler handler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            String str= (String) msg.obj;
            textView1.setText(str);
        }
    };
//使用子线程来提交一个消息给主线程的Looper执行
    public void runnableThreadTest(){
        new Thread(new Runnable() {
            @Override
            public void run() {
               while (true) {
                    long cut = System.currentTimeMillis();
                    /*Handler是用来发送消息和创建消息队列中的消息的
                    * Message 常用的有以下数据类型可传递：
                    * int arg1：参数一，用于传递不复杂的数据，复杂数据使用setData()传递。
                    * int arg2：参数二，用于传递不复杂的数据，复杂数据使用setData()传递。
                    * Object obj：传递一个任意的对象。
                    * int what：定义的消息码，一般用于设定消息的标志。
                    * */
                    Message message = new Message();
                    message.obj = cut+"";
                    handler.sendMessage(message);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    updateUi(cut+"",true);
                }
            }
        }).start();
    }

效果：

但在子线程中想使用Looper时，需要先创建一个Looper管理器来管理消息队列，如下：

/*
* Looper对象通过MessageQueue来存放消息和事件。一个线程只能有一个Looper，对应一个MessageQueue。有以下几个方法：
* public static prepare();
* public static myLooper();
* public static loop();
* public void quit();
* */
public class threadInAndroidTest {
private TextView tv;
private ProgressBar progressBar;
private MainActivity context;
   public threadInAndroidTest(TextView t,ProgressBar pb) {
        tv = t;
        progressBar = pb;
        progressBar.setMax(100);

    }

    class HandlerForLoop extends Handler{

        public HandlerForLoop(Looper l){
            super(l);
        }

        @Override
        public void handleMessage(Message msg) {
            String str = (String) msg.obj;
            tv.setText(str);
        }
    }
    class threadForLoop extends Thread{
        HandlerForLoop hfl;
        @Override
        public void run() {
            Looper.prepare();//必须最先调用,只有主线程（Ui线程）采用默认初始化Looper管理，子线程需要先初始化
                            //一个管理器Looper。
            Looper looper = Looper.myLooper();//获取到子线程的Looper
            hfl = new HandlerForLoop(looper);//创建handler
            Message message = Message.obtain();//消息包装
            message.obj = "i am looper";
            hfl.sendMessage(message);//发送
            Looper.loop();//Looper管理消息循环调用，直到退出为止
        }
    }
}

主函数中调用：

threadInAndroidTest tiat = new threadInAndroidTest(textView,bar);
tiat.new threadForLoop().start();

效果：

2、使用AsyncTask来更新Ui： AsyncTask是轻量级的Ui更新线程，是Thread+Handler良好封装得来的。又四个方法：
doInBackground：被放到后台，用来执行耗时的逻辑，执行的结果返回即可
onPreExecute ：执行后台任务前的回调，更新Ui用
onProgressUpdate ：任务执行中的回调，更新进度条
onPostExecute：任务被执行后的回调,更新Ui
onCancelled：任务被取消时的回调
下面模拟演示下载使用AsyncTask的情景。

public class threadInAndroidTest {
private TextView tv;
private ProgressBar progressBar;
private MainActivity context;
   public threadInAndroidTest(TextView t,ProgressBar pb) {
        tv = t;
        progressBar = pb;
        progressBar.setMax(100);

    }
        class MyAsyncTask extends AsyncTask<String,Integer,String>{
            MyAsyncTask(){}
            //执行后台耗时进程
            @Override
            protected String doInBackground(String... params) {
                Log.e("tag",">>>>>>>>doInBackground>>>>>>>>>");
                int val = 0;
                while (true) {
                    publishProgress(val);
                    val += 5;
                    if (val >100)
                        break;
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                return "success";
            }
            //onPreExecute执行后台任务前的回调,更新Ui用
            @Override
            protected void onPreExecute() {
                Log.e("tag",">>>>>>>>>>>onPreExecute>>>>>>>>>");
                tv.setText("begin download...");
            }

            //onProgressUpdate任务执行中的回调，更新进度条
            @Override
            protected void onProgressUpdate(Integer... values) {
                Log.e("tag",">>>>>>>>>onProgressUpdate>>>>>>>>>");
                progressBar.setProgress(values[0]);
                tv.setText("load "+ values[0]+"%");
            }

            //onPostExecute任务被执行后的回调,更新Ui
            @Override
            protected void onPostExecute(String s) {
                Log.e("tag",">>>>>>>>>onPostExecute>>>>>>>>");
                tv.setText("download result... "+s);
            }

            //onCancelled任务被取消时的回调
            @Override
            protected void onCancelled() {
                Log.e("tag",">>>>>>>>onCancelled>>>>>>>>");
                tv.setText("task was cancel...");
                progressBar.setProgress(0);
            }
        }

        public MyAsyncTask getAsync(){
            return new MyAsyncTask();
        }
}

在MainActivity 中的调用：

threadInAndroidTest.MyAsyncTask  mytask;//全局

threadInAndroidTest tiat = new threadInAndroidTest(textView,bar);
mytask = tiat.getAsync();
mytask.execute("");

通过按钮取消这个任务：

   @OnClick(R.id.cancelB)
    public void OnClick(View view)
    {
        mytask.cancel(true);
    }

效果如下：

关于AsyncTask是如何对Thread和Handler进行封装的，可以参看源码和官方文档，这里只是给出怎么使用。

3、使用runOnUiThread和post
这两个是比较简单的，可以直接创建来更新，下面给出代码不演示：

  public void updateUiUseViewPost(){

        new Thread(){
            @Override
            public void run() {
                tv.post(new Runnable() {
                    @Override
                    public void run() {
                        tv.setText("Using view post");
                    }
                });
            }
        }.start();
    }

    public void updateUiUseHandlerPost(){
        new Thread(){
            @Override
            public void run() {
                Handler handler = new Handler();
                handler.post(new Runnable() {
                    @Override
                    public void run() {
                        tv.setText("Using Handler Post");
                    }
                });
            }
        }.start();
    }
    public void updateUiUseRunOnUiThread(){
        new Thread(){
            @Override
            public void run() {
                context.runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        tv.setText("Using Handler Post");
                    }
                });
            }
        }.start();
    }

Android线程池
线程池的基本思想还是一种对象池的思想，开辟一块内存空间，里面存放了众多(未死亡)的线程，池中线程执行调度由池管理器来处理。当有线程任务时，从池中取一个，执行完成后线程对象归池，这样可以避免反复创建线程对象所带来的性能开销，节省了系统的资源。
好处：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。
线程池创建使用一般有下面三种方式：
FixedThreadPool：它是一种线程数量固定的线程池，当线程处于空闲状态时，它们并不会被回收，除非线程池被关闭了，当所有的线程都处于活动状态时，新任务都会处于等待状态，直到有线程空闲出来。由于FixedThreadPool只有核心线程并且这些核心线程不会被回收，这意味着它能够更加快速地响应外界的请求。
CachedThreadPool：它是一种线程数量不定的线程池，它只有非核心线程，并且其最大线程数为Integer.MAX_VALUE，实际上就相当于最大线程数可以任意大，当线程池中的线程都处于活动状态时，线程池会创建新的线程来处理新任务，空闲线程有超时机制，这个超时时长为60秒
SingleThreadExecutor：这类线程池内部只有一个核心线程，它确保所有的任务都在同一个线程中按顺序执行。
基本使用步骤：
调用Executors类的静态工厂方法创建一个ExecutorService对象，该对象代表一个线程池。
创建Runnable实现类或Callable实现类的实例，作为线程执行任务。
调用ExecutorService对象的submit()方法来提交Runnable实例或Callable实例。
当不想使用线程池的时候，调用ExecutorService对象的shutdown()方法来关闭线程池。
下面封装了一个类，通过几个方法来选择使用哪种线程池

package com.example.multithreadtest;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 *ThreadPoolExecutor执行任务时遵循如下规则：
 * 1、如果线程池中的线程数量未达到核心线程的数量，那么会直接启动一个核心线程来执行任务
 * 2、如果线程池中的线程数量已经达到或者超过核心线程的数量，那么任务会被插入到任务队列中排队等待执行。
 * 3、如果在步骤2中无法将任务插入到任务队列中，这往往是由于任务队列已满，这个时候如果线程数量未达到线
 *    程池规定的最大值，那么会立刻启动一个非核心线程来执行。
 * 4、如果步骤3中线程数量已经达到线程池规定的最大值，那么就拒绝执行此任务。
 */

public class threadPoolTest {

    private MainActivity listener;
    private static threadPoolTest threadPool;
    private ExecutorService cachedPool;//缓冲池
    private ExecutorService signalCachedPool;//容量为1的缓冲池
    private ExecutorService fixThreadPool;//容量固定的缓冲池

    private threadPoolTest(MainActivity l){
        listener = l;
        cachedPool = Executors.newCachedThreadPool();//缓冲池，大小为Integer.MAX_VALUE
        signalCachedPool = Executors.newSingleThreadExecutor();//容量为1的缓冲池
        fixThreadPool = Executors.newFixedThreadPool(6);//容量为6的缓冲池
    }
    public static threadPoolTest getPoolInstance(MainActivity l)
    {
        return threadPool==null?threadPool=new threadPoolTest(l):threadPool;
    }
    //使用缓冲池
    public void useCachedPool(Thread thread){
        cachedPool.submit(thread);
    }
    public void shutDownCachedPool(){
        cachedPool.shutdownNow();
    }

    //使用容量为1的缓冲池
    public void useSignalPool(Thread thread){
        signalCachedPool.submit(thread);
    }
    public void shutDownSignalPool(){
        signalCachedPool.shutdownNow();
    }
    //使用容量固定的缓冲池
    public void useFixThreadPool(Thread thread)
    {
        fixThreadPool.submit(thread);
    }
    public void shutDownFixPool(){
        fixThreadPool.shutdownNow();
    }
}

在MainActivity中调用：（注意这里创建线程使用了上面的Thread和Callable）

threadPool = threadPoolTest.getPoolInstance(this);
myTh = new myThread(this);
myTh.start();
threadPool.useCachedPool(myTh);

call = new CallableTest(this);
task = new FutureTask<String>(call);
CallThread = new Thread(task);
threadPool.useCachedPool(CallThread);

效果跟上面使用Thread和Callable创建线程一样的。
关于Android线程，还有IntentService，这种方式用来执行后台耗时动作，在这里不展开。