Android基础知识之 - Thread

转载请注明出处amoscxy的博客：https://mp.csdn.net/mdeditor/80163913

Android基础知识之 - Thread

主线程又称为UI线程，UI线程中不能执行耗时的操作

1.1 线程的基本用法

定义一个线程只需要新建一个类继承自Thread，然后重写父类的run()方法，并在里面编写耗时逻辑

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

启动线程，只需new出MyThread的实例，然后调用它的start()方法，这样run()方法中的代码就会在子线程当中进行运行了

new MyThread().start();

继承Thread的方法耦合性较高，更多的时候我们都会选择使用实现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();

1.2 在子线程中更新UI

Android不允许在子线程中进行UI操作，但有时候，我们必须在子线程里去执行一些耗时任务，然后根据任务的执行结果来更新响应UI控件，该如何处理？

Android提供了一套异步消息处理机制，完美地解决了在子线程中进行UI操作的问题

• 最终效果
  

• 实例目录
  

• activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <Button
        android:id="@+id/change_text"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Change Text" />

    <TextView
        android:id="@+id/text"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerInParent="true"
        android:text="Hello world"
        android:textSize="20sp" />

</RelativeLayout>

布局中有一个Button和一个TextView，点击Button时TextView内容进行了相应改变

• MainActivity

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    public static final int UPDATE_TEXT = 1;

    private TextView text;

    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 = new Message();
                        message.what = UPDATE_TEXT;
                        handler.sendMessage(message); // 将Message对象发送出去
                    }
                }).start();
                break;
            default:
                break;
        }
    }
}

这里我们先定义了一个整型常量UPDATE_TEXT，用于表示更新TextView这个动作，然后新增一个Handler对象，并重写父类的handleMessage()方法，在这里对具体的Message进行处理，如果发现Message的what字段的值等于UPDATAE_TEXT，就将TextView显示的内容改成Nice to meet you

点击事件中，我们没有在子线程里直接进行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

1.3 解析异步消息处理机制

Android中的异步消息处理主要由4部分组成：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的handlerMessage()方法中，每个线程中也只会有一个Looper对象

• 了解了Message、Handler、MessageQueue以及Looper的基本概念后，我们再来把异步消息处理的整个流程梳理一遍：

  • 首先需要在主线程当中创建一个Handler对象，并重写handlerMessage()方法，然后当子线程中需要进行UI操作时，就创建一个Message对象，并通过Handler的sendMessage()方法将这条消息发送出去，之后这条消息被添加到MessageQueue的队列中等待被处理，而Looper则会一直尝试从MessageQueue中取出待处理的消息，最后分发回Handler的handleMessage()方法中，由于Handler是在主线程中创建的，所以此时handlerMessage()方法中的代码也会在主线程中运行，于是我们在这里就可以安心地进行UI操作了，一条Message经过这样一个流程的辗转调用后，也就从子线程进入到主线程，从不能更新UI变成了可以更新UI，整个异步消息处理的核心思想也就是如此

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

转载请注明出处amoscxy的博客：https://mp.csdn.net/mdeditor/80163913