Android的多线程---《第一行代码Android》

异步消息处理机制

Android中异步消息处理由4个部分组成：Message、Handler、MessageQueue和Looper。
- Message：消息的载体。
- Handler：消息的处理者，用于发送和处理消息。sendMessage()发送数据，handleMessage()处理消息。
- MessageQueue：消息队列。消息被发送后，存储在MessageQueue中等待被处理。每个线程中只会有一个MessageQueue。
- Looper：每个线程中MessageQueue的管家，调用Looper的loop()方法后，就会进入到一个无限循环当中，然后发现MessageQueue中存在一条信息，就把它取出来并传递到handler的handleMessage()方法中。每个线程中也只有一个Looper。
步骤：
首先，在主线程中创建handler实例，并重写handleMessage()方法。
当子线程中需要更新ui时，就创建一个Message对象，并通过handler将信息发送出去。
之后这条信息就被添加到MessageQueue消息队列中等待被处理，
而Looper则会一直尝试从MessageQueue中取出待处理消息，最后分发回handler的handleMessage()方法中。

runOnUiThread()方法其实就是一个异步消息处理机制的接口封装，背后原理也是这。

例子：

package com.example.androidthreadtest;

import android.os.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

/**
 * 这个例子实现的是，点击按钮后，textview显示的内容改变
 */
public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    public static final int UPDATE_TEXT = 1;

    private TextView text;

    /**
     * Handler，消息的发送和接收类，创建时实现handleMessage()函数来接收消息，并根据消息进行具体操作。
     */
    private Handler handler = new Handler() {

        public void handleMessage(Message msg) {
            switch (msg.what) {
                case UPDATE_TEXT:
                    // 在这里可以进行UI操作
                    text.setText("Nice to meet you");
                    break;
                default:
                    break;
            }
        }

    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        text = (TextView) findViewById(R.id.text);
        Button changeText = (Button) findViewById(R.id.change_text);
        changeText.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.change_text:
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        /**
                         * Message，消息类，数据的载体，
                         *     message.what携带字符串，arg1和arg2携带整形数据，obj携带Object对象
                         *
                         * 使用handler把message发送出去，handler的handleMessage()方法会自动接收并处理
                         */
                        Message message = new Message();
                        message.what = UPDATE_TEXT;
                        handler.sendMessage(message); // 将Message对象发送出去
                    }
                }).start();
                break;
            default:
                break;
        }
    }

}

AsyncTask

AsyncTask是Android提供的很好用的异步消息处理机制工具，本身是一个抽象类，需要我们新建一个类去继承它。
AsyncTask的使用诀窍就是，在doInBackground()方法中执行具体的耗时任务，在onProgressUpdate()方法中进行UI操作，在onPostExecute()方法中执行一些任务的收尾工作。
想要启动这个任务，只需要以下代码即可：

new DownloadTask().execute();

一个下载的例子：

package com.example.servicebestpractice;

import android.os.AsyncTask;
import android.os.Environment;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.RandomAccessFile;

import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

/**
 * 这个类模拟的是下载文件
 *
 * 继承AsyncTask类，需要指定3个泛型参数：
 *    第一个：Params--在执行AsyncTask时需要传入的参数，可用于在后台任务中使用。为void时，表示执行AsyncTask时不需要传入参数给后台任务。
 *    第二个：Progress--后台任务执行时，如果需要在界面上显示当前的进度，则使用这里指定的泛型作为进度单位。
 *    第三个：Result--当任务执行完毕后，如果需要对结果进行返回，则使用这里指定的泛型作为返回值类型。
 */
public class DownloadTask extends AsyncTask<String, Integer, Integer> {

    public static final int TYPE_SUCCESS = 0;
    public static final int TYPE_FAILED = 1;
    public static final int TYPE_PAUSED = 2;
    public static final int TYPE_CANCELED = 3;


    private DownloadListener listener;

    private boolean isCanceled = false;

    private boolean isPaused = false;

    private int lastProgress;

    public DownloadTask(DownloadListener listener) {
        this.listener = listener;
    }

    /**
     * 这个方法中的所有代码都会在子线程中运行，我们在这里执行耗时任务。
     * 任务一旦完成就可以通过return语句来将任务的执行结果返回，
     *     如果AsyncTask的第三个泛型参数指定的是Void，就可以不返回任务执行结果。
     * 这个方法是不可以进行UI操作，如果需要更新UI元素，比如反馈当前任务的执行进度，
     *     可以调用publishProgress(Progress...)方法来完成。
     * @param params
     * @return
     */
    @Override
    protected Integer doInBackground(String... params) {
        InputStream is = null;
        RandomAccessFile savedFile = null;
        File file = null;
        try {
            long downloadedLength = 0; // 记录已下载的文件长度
            String downloadUrl = params[0];
            String fileName = downloadUrl.substring(downloadUrl.lastIndexOf("/"));
            String directory = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS).getPath();
            file = new File(directory + fileName);
            if (file.exists()) {
                downloadedLength = file.length();
            }
            long contentLength = getContentLength(downloadUrl);
            if (contentLength == 0) {
                return TYPE_FAILED;
            } else if (contentLength == downloadedLength) {
                // 已下载字节和文件总字节相等，说明已经下载完成了
                return TYPE_SUCCESS;
            }
            OkHttpClient client = new OkHttpClient();
            Request request = new Request.Builder()
                    // 断点下载，指定从哪个字节开始下载
                    .addHeader("RANGE", "bytes=" + downloadedLength + "-")
                    .url(downloadUrl)
                    .build();
            Response response = client.newCall(request).execute();
            if (response != null) {
                is = response.body().byteStream();
                savedFile = new RandomAccessFile(file, "rw");
                savedFile.seek(downloadedLength); // 跳过已下载的字节
                byte[] b = new byte[1024];
                int total = 0;
                int len;
                while ((len = is.read(b)) != -1) {
                    if (isCanceled) {
                        return TYPE_CANCELED;
                    } else if(isPaused) {
                        return TYPE_PAUSED;
                    } else {
                        total += len;
                        savedFile.write(b, 0, len);
                        // 计算已下载的百分比
                        int progress = (int) ((total + downloadedLength) * 100 / contentLength);
                        //执行UI操作，反馈当前任务的执行进度
                        publishProgress(progress);
                    }
                }
                response.body().close();
                return TYPE_SUCCESS;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (is != null) {
                    is.close();
                }
                if (savedFile != null) {
                    savedFile.close();
                }
                if (isCanceled && file != null) {
                    file.delete();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return TYPE_FAILED;
    }

    /**
     * 调用publishProgress(Progress...)方法后，就会调用很快被调用。
     * 该方法中携带的参数就是在后台任务中传递过来的。
     * 在这个方法中可以对UI进行操作。
     * @param values
     */
    @Override
    protected void onProgressUpdate(Integer... values) {
        int progress = values[0];
        if (progress > lastProgress) {
            listener.onProgress(progress);
            lastProgress = progress;
        }
    }

    /**
     * 当后台任务执行完毕并通过return语句进行返回时，这个方法就很快会被调用。
     * 返回的数据会作为参数传递到这个方法中，可以利用返回的数据进行一些UI操作。
     * @param status
     */
    @Override
    protected void onPostExecute(Integer status) {
        switch (status) {
            case TYPE_SUCCESS:
                listener.onSuccess();
                break;
            case TYPE_FAILED:
                listener.onFailed();
                break;
            case TYPE_PAUSED:
                listener.onPaused();
                break;
            case TYPE_CANCELED:
                listener.onCanceled();
            default:
                break;
        }
    }

    /**
     * 后台任务开始执行前调用，用于进行一些界面上的初始化操作。
     * 这里没有什么要做到。
     */
    @Override
    protected void onPreExecute() {
        super.onPreExecute();
    }


    public void pauseDownload() {
        isPaused = true;
    }


    public void cancelDownload() {
        isCanceled = true;
    }

    private long getContentLength(String downloadUrl) throws IOException {
        OkHttpClient client = new OkHttpClient();
        Request request = new Request.Builder()
                .url(downloadUrl)
                .build();
        Response response = client.newCall(request).execute();
        if (response != null && response.isSuccessful()) {
            long contentLength = response.body().contentLength();
            response.close();
            return contentLength;
        }
        return 0;
    }


}