26
2017
09

5.0 Android 中多线程的用法大全

点此进入:从零快速构建APP系列目录导图
点此进入:UI编程系列目录导图
点此进入:四大组件系列目录导图
点此进入:数据网络和线程系列目录导图

当我们需要执行一些耗时操作,比如说发起一条网络请求时,考虑到网速等其他原因,服务器未必会立刻响应我们的请求,如果不将这类操作放在子线程里去运行,就会导致主线程被阻塞住,从而影响用户对软件的正常使用,那么这就需要用到异步处理的知识,下面我们就开始相关的学习。

本节例程下载地址:WillFlowThread

一、线程的基本用法

1、继承 Thread

Android 多线程编程其实并不比 Java 多线程编程特珠,基本都是使用相同的语法。比如定义一个线程只需要新建一个类继承自 Thread,然后重写父类的 run() 方法,并在里面编写耗时逻辑即可,如下所示:

        class MyThread extends Thread {
            @Override
            public void run() {
                // 处理具体的逻辑
            }
        }

那么该如何启动这个线程呢?其实也很简单,只需要 new 出 MyThread 的实例,然后调用它的 start() 方法,这样 run() 方法中的代码就会在子线程当中运行了,如下所示:

new MyThread().start();

2、实现 Runnable 接口

当然,使用继承的方式耦合性有点高,更多的时候我们都会选择使用实现 Runnable 接口的方式来定义一个线程,如下所示:

        class MyThread implements Runnable {
            @Override
            public void run() {
                // 处理具体的逻辑
            }
        }

如果使用了这种写法,启动线程的方法也需要进行相应的改变,如下所示:

MyThread myThread = new MyThread();
new Thread(myThread).start();

可以看到, Thread 的构造函数接收一个 Runnable 参数,而我们 new 出的 MyThread 正是一个实现了 Runnable 接口的对象,所以可以直接将它传入到 Thread 的构造函数里。接着调用 Thread 的 start() 方法, run() 方法中的代码就会在子线程当中运行了。

当然,如果你不想专门再定义一个类去实现 Runnable 接口,也可以使用匿名类的方式,这种写法更为常见,如下所示:

        new Thread(new Runnable() {
            @Override
            public void run() {
                // 处理具体的逻辑
            }
        }).start();

了解了线程的基本用法后,下面我们来看一下 Android 多线程编程与 Java 多线程编程不同的地方。

二、在子线程中更新 UI

和许多其他的 GUI 库一样, Android 的 UI 也是线程不安全的。也就是说,如果想要更新应用程序里的 UI 元素,则必须在主线程中进行,否则就会出现异常。

首先修改 activity_main.xml 中的代码,如下所示:
<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" tools:context="com.wgh.willflowthread.MainActivity">

    <TextView  android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Hello World!" android:textColor="#0583fa" android:textSize="25dp" />

    <Button  android:id="@+id/button_thread" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="异步请求" />

</android.support.constraint.ConstraintLayout>

布局文件中定义了两个控件, TextView 用于在屏幕的正中央显示一个 Hello world 字符串, Button 用于改变 TextView 中显示的内容,我们希望在点击 Button 后可以把 TextView 中显示的字符串改成 Nice to meet you。

接下来修改 MainActivity 中的代码,如下所示:
public class MainActivity extends AppCompatActivity {

    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);
        mButton = (Button) findViewById(R.id.button_thread);
        mButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        mTextView.setText("Nice to meet you");
                    }
                }).start();
            }
        });
    }
}

可以看到,我们在 Change Text 按钮的点击事件里面开启了一个子线程,然后在子线程中调用 TextView 的 setText() 方法将显示的字符串改成 Nice to meet you。代码的逻辑非常简单,只不过我们是在子线程中更新 UI 的。

现在运行一下程序,并点击异步请求按钮,你会发现程序果然崩溃了!

然后观察 LogCat 中的错误日志,可以看出是由于在子线程中更新 UI 所导致的:

由此证实了 Android 确实是不允许在子线程中进行 UI 操作的。但是有些时候,我们必须在子线程里去执行一些耗时任务,然后根据任务的执行结果来更新相应的 UI 控件。对于这种情况, Android 提供了一套异步消息处理机制,完美地解决了在子线程中进行UI 操作的问题,接下来我们看一下它的用法。

修改 MainActivity 中的代码,如下所示:
public class MainActivity extends AppCompatActivity {

    public static final int UPDATE_TEXT = 0;
    ......
    private Handler mHandler = new Handler() {
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case UPDATE_TEXT:
                    // 在这里可以进行UI操作
                    mTextView.setText("Nice to meet you");
                    break;
                default:
                    break;
            }
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ......
        mButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        Message message = new Message();
                        message.what = UPDATE_TEXT;
                        mHandler.sendMessage(message); // 将Message对象发送出去
                    }
                }).start();
            }
        });
    }
}

可以看到,这次我们并没有在子线程里直接进行 UI 操作,而是创建了一个 Message(android.os.Message)对象,并将它的 what 字段的值指定为 UPDATE_TEXT,然后调用 Handler 的 sendMessage() 方法将这条 Message 发送出去。很快,Handler 就会收到这条 Message,并在 handleMessage() 方法中对它进行处理。注意此时 handleMessage() 方法中的代码就是在主线程当中运行的了,所以我们可以放心地在这里进行 UI 操作。接下来对 Message 携带的 what 字段的值进行判断,如果等于UPDATE_TEXT,就将 TextView 显示的内容改成 Nice to meet you。

现在重新运行程序,可以看到点击按钮后的效果:

这样我们就已经掌握了 Android 异步消息处理的基本用法,使用这种机制就可以出色地解决掉在子线程中更新 UI 的问题。不过恐怕我们对它的工作原理还不是很清楚,下面我们就来分析一下 Android 异步消息处理机制到底是如何工作的。

三、解析异步消息处理机制

Android 中的异步消息处理主要由四个部分组成, Message、 Handler、 MessageQueue 和 Looper。其中 Message 和 Handler 在刚才我们已经接触过了,而 MessageQueue 和 Looper 对于我们来说还是全新的概念,下面我就对这四个部分进行一下简要的介绍。

1. Message

Message 是在线程之间传递的消息,它可以在内部携带少量的信息,用于在不同线程之间交换数据。刚才我们使用到了 Message 的 what 字段,除此之外我们还可以使用 arg1 和 arg2 字段来携带一些整型数据,使用 obj 字段携带一个 Object 对象。

2. Handler

Handler 顾名思义也就是处理者的意思,它主要是用于发送和处理消息的。发送消息一般是使用 Handler 的 sendMessage() 方法,而发出的消息经过一系列地辗转处理后,最终会传递到 Handler 的 handleMessage() 方法中。

3. MessageQueue

MessageQueue 是消息队列的意思,它主要用于存放所有通过 Handler 发送的消息。这部分消息会一直存在于消息队列中等待被处理,每个线程中只会有一个 MessageQueue 对象。

4. Looper

Looper 是每个线程中的 MessageQueue 的管家,调用 Looper 的 loop() 方法后,就会进入到一个无限循环当中,然后每当发现 MessageQueue 中存在一条消息,就会将它取出,并传递到 Handler 的 handleMessage( )方法中,每个线程中也只会有一个 Looper 对象。

了解了 Message、 Handler、 MessageQueue 以及 Looper 的基本概念后,我们再来对异步消息处理的整个流程梳理一遍:
- 首先需要在主线程当中创建一个 Handler 对象,并重写 handleMessage() 方法。然后当子线程中需要进行 UI 操作时,就创建一个 Message 对象,并通过 Handler 将这条消息发送出去。
- 之后这条消息会被添加到 MessageQueue 的队列中等待被处理,而 Looper 则会一直尝试从 MessageQueue 中取出待处理消息,最后分发回 Handler 的 handleMessage() 方法中。
- 由于 Handler 是在主线程中创建的,所以此时 handleMessage() 方法中的代码也会在主线程中运行,于是我们在这里就可以安心地进行 UI 操作了。

整个异步消息处理机制的流程示意图:

![Upload 选区_131.png failed. Please try again.]

一条 Message 经过这样一个流程的辗转调用后,也就从子线程进入到了主线程,从不能更新 UI 变成了可以更新 UI,整个异步消息处理的核心思想也就是如此。

四、使用 AsyncTask

为了更加方便我们在子线程中对 UI 进行操作, Android 还提供了另外一些好用的工具, AsyncTask 就是其中之一。借助 AsyncTask,即使我们对异步消息处理机制完全不了解,也可以十分简单地从子线程切换到主线程。当然, AsyncTask 背后的实现原理也是基于异步消息处理机制的,只是 Android 帮我们做了很好的封装而已。

首先来看一下 AsyncTask 的基本用法,由于 AsyncTask 是一个抽象类,所以如果我们想使用它,就必须要创建一个子类去继承它。在继承时我们可以为 AsyncTask 类指定三个泛型参数,这三个参数的用途如下:

1. Params

在执行 AsyncTask 时需要传入的参数,可用于在后台任务中使用。

2. Progress

后台任务执行时,如果需要在界面上显示当前的进度,则使用这里指定的泛型作为进度单位。

3. Result

当任务执行完毕后,如果需要对结果进行返回,则使用这里指定的泛型作为返回值类型。

所以一个最简单的自定义 AsyncTask 就可以写成如下方式:

    class DownloadTask extends AsyncTask<Void, Integer, Boolean> {
        ……
    }

这里我们把 AsyncTask 的第一个泛型参数指定为 Void,表示在执行 AsyncTask 的时候不需要传入参数给后台任务。第二个泛型参数指定为 Integer,表示使用整型数据来作为进度显示单位。第三个泛型参数指定为 Boolean,则表示使用布尔型数据来反馈执行结果。

当然,目前我们自定义的 DownloadTask 还是一个空任务,并不能进行任何实际的操作,我们还需要去重写 AsyncTask 中的几个方法才能完成对任务的定制。经常需要去重写的方法有以下四个:

1. onPreExecute()

这个方法会在后台任务开始执行之前调用,用于进行一些界面上的初始化操作,比如显示一个进度条对话框等。

2. doInBackground(Params…)

这个方法中的所有代码都会在子线程中运行,我们应该在这里去处理所有的耗时任务。任务一旦完成就可以通过 return 语句来将任务的执行结果返回,如果 AsyncTask 的第三个泛型参数指定的是 Void,就可以不返回任务执行结果。注意,在这个方法中是不可以进行 UI 操作的,如果需要更新 UI 元素,比如说反馈当前任务的执行进度,可以调用 publishProgress(Progress…) 方法来完成。

3. onProgressUpdate(Progress…)

当在后台任务中调用了 publishProgress(Progress…) 方法后,这个方法就会很快被调用,方法中携带的参数就是在后台任务中传递过来的。在这个方法中可以对 UI 进行操作,利用参数中的数值就可以对界面元素进行相应地更新。

4. onPostExecute(Result)

当后台任务执行完毕并通过 return 语句进行返回时,这个方法就很快会被调用。返回的数据会作为参数传递到此方法中,可以利用返回的数据来进行一些 UI 操作,比如说提醒任务执行的结果,以及关闭掉进度条对话框等。

所以一个比较完整的自定义 AsyncTask 就可以写成如下方式:

/** * Created by : WGH. */
public class DownloadTask extends AsyncTask<Void, Integer, Boolean> {

    @Override
    protected void onPreExecute() {
        progressDialog.show(); // 显示进度对话框
    }

    @Override
    protected Boolean doInBackground(Void... voids) {
        try {
            while (true) {
                int downloadPercent = doDownload();
                publishProgress(downloadPercent);
                if (downloadPercent >= 100) {
                    break;
                }
            }
        } catch (Exception e) {
            return false;
        }
        return true;
    }

    @Override
    protected void onProgressUpdate(Integer... values) {
        // 在这里更新下载进度
        progressDialog.setMessage("Downloaded " + values[0] + "%");
    }

    @Override
    protected void onPostExecute(Boolean result) {
        progressDialog.dismiss(); // 关闭进度对话框
        // 在这里提示下载结果
        if (result) {
            Toast.makeText(context, "Download succeeded", Toast.LENGTH_SHORT).show();
        } else {
            Toast.makeText(context, " Download failed", Toast.LENGTH_SHORT).show();
        }
    }
}

在这个 DownloadTask 中,我们在 doInBackground() 方法里去执行具体的下载任务。这个方法里的代码都是在子线程中运行的,因而不会影响到主线程的运行。doDownload() 这个方法用于计算当前的下载进度并返回,我们假设这个方法已经存在了。在得到了当前的下载进度后,下面就该考虑如何把它显示到界面上了,由于 doInBackground() 方法是在子线程中运行的,在这里肯定不能进行 UI 操作,所以我们可以调用 publishProgress() 方法并将当前的下载进度传进来,这样 onProgressUpdate() 方法就会很快被调用,在这里就可以进行 UI 操作了。

当下载完成后, doInBackground() 方法会返回一个布尔型变量,这样 onPostExecute() 方法就会很快被调用,这个方法也是在主线程中运行的。然后在这里我们会根据下载的结果来弹出相应的 Toast 提示,从而完成整个 DownloadTask 任务。

总之使用 AsyncTask 的诀窍就是:在 doInBackground()方法中去执行具体的耗时任务,在 onProgressUpdate() 方法中进行 UI 操作,在 onPostExecute() 方法中执行一些任务的收尾工作。

如果想要启动这个任务,只需编写以下代码即可:

new DownloadTask().execute();

以上就是 AsyncTask 的基本用法,我们并不需要去考虑什么异步消息处理机制,也不需要专门使用一个 Handler 来发送和接收消息,只需要调用一下 publishProgress() 方法就可以轻松地从子线程切换到 UI 线程了。

注意:虽然 AsyncTask 让我们的异步工作变得如此简单,但是使用工作线程时可能会遇到另一个问题,即:运行时配置变更(例如:用户更改了屏幕方向)导致 Activity 意外重启,这可能会销毁工作线程。关于如何在这种重启情况下坚持执行任务,以及如何在 Activity 被销毁时正确地取消任务,我们会在接下来的文章当中说明和解决。

五、线程安全方法

在某些情况下,我们实现的方法可能会从多个线程调用,因此编写这些方法时必须确保其满足线程安全的要求。

这一点主要适用于可以远程调用的方法,如绑定服务中的方法。如果对 IBinder 中所实现方法的调用源自运行 IBinder 的同一进程,则该方法在调用方的线程中执行。但是,如果调用源自其他进程,则该方法将在从线程池选择的某个线程中执行(而不是在进程的 UI 线程中执行),线程池由系统在与 IBinder 相同的进程中维护。例如,即使服务的 onBind() 方法将从服务进程的 UI 线程调用,在 onBind() 返回的对象中实现的方法仍会从线程池中的线程调用。 由于一个服务可以有多个客户端,因此可能会有多个池线程在同一时间使用同一 IBinder 方法。因此,IBinder 方法必须实现为线程安全方法。

同样,我们之前讲解的内容提供程序也可接收来自其他进程的数据请求。尽管 ContentResolver 和 ContentProvider 类隐藏了如何管理进程间通信的细节,但响应这些请求的 ContentProvider 方法(query()、insert()、delete()、update() 和 getType() 方法)将从内容提供程序所在进程的线程池中调用,而不是从进程的 UI 线程调用。 由于这些方法可能会同时从任意数量的线程调用,因此它们也必须实现为线程安全方法。

关于线程安全方法我们会在之后的文章当中加以说明和解决。

点此进入:GitHub开源项目“爱阅”,下面是“爱阅”的效果图:


联系方式:

简书:WillFlow
CSDN:WillFlow
微信公众号:WillFlow

微信公众号:WillFlow

上一篇:3.2 使用 URL 类请求和提交数据详解 下一篇:UICC之UiccCardApplication