亲宝软件园·资讯

展开

Android同步异步任务与多线程及Handler消息处理机制基础详细讲解

发飙的蜗牛YR 人气:0

同步与异步

同步的执行任务:在执行程序时,如果没有收到执行结果,就一直等,不继续往下执行,直到收到执行结果,才接着往下执行。

异步的执行任务:在执行程序时,如果遇到需要等待的任务,就另外开辟一个子线程去执行它,自己继续往下执行其他程序。子线程有结果时,会将结果发送给主线程

Android中的多线程

线程:通俗点讲就是一个执行过程。多线程自然就是多个执行过程而已。

程序中可能有多个任务,如果只有一个线程,那么就只能一个接一个的执行了。类似同步执行任务。很明显会比较慢,因为只有上一个任务执行完,才能进行下一个。

因此,我们需要多线程来分别执行这些任务。这也就是对应了上面说的异步执行任务。

Android中的多线程与主线程与子线程

类比到我们Android app程序。App一启动,本身就是一个线程,这个线程被称为主线程mainThread,负责显示界面,跟用户交互。

另外,界面通常被称为UI(User Interface),因此,主线程也被称为UI线程。

两个原则:

主线程不能执行网络请求/文件读写等耗时操作

子线程不能执行UI刷新

package com.example.androidnetwork;
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.TextView;
import android.widget.Toast;
public class MainActivity2 extends AppCompatActivity {
    private TextView tvContent;
    private String strFromNet;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main2);
        tvContent = findViewById(R.id.tv_content);
    }
    public void start(View view) {
        //做一个耗时任务
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                String stringFromNet = getStrFromNet();
                //子线程中执行UI操作会报错
                tvContent.setText(stringFromNet);
            }
        });
        thread.start();
        Toast.makeText(this, "任务完成!", Toast.LENGTH_SHORT).show();
    }
    private String getStrFromNet() {
        //假装从网络上获取了一个字符串
        String result = " ";
        StringBuilder stringBuilder = new StringBuilder();
        //模拟一个耗时操作
        for (int i = 0; i < 100; i++) {
            stringBuilder.append("字符串" + i);
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        result = stringBuilder.toString();
        return result;
    }
}

报错:android.view.ViewRootImpl$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.

说明只有主线程才能进行View里的UI操作进行交互。

Handler异步通信系统

Handler机制主要的几个角色:Handler、Message、Looper、MessageQueue

异步消息Handler处理机制

首先在主线程当中创建一个Handler对象,并重写handleMessage()方法。然后当子线程中需要进行UI操作时,就创建一个Message对象,并通过Handler将这条消息发送出去。之后这条消息就会被添加到MessageQueue队列中等待被处理,而Looper则会一直尝试从MessageQueue中取出待处理消息,最后分发回Handler的handleMessage()方法中。由于Handler是在主线程中创建的,所以此时handleMessage()方法中的代码也会在主线程中运行,所以可以安心的进行UI操作。

这样一条Message经过这样一个流程的辗转调用后,也就从子线程进入到了主线程,从而从不能更新UI到能更新UI。

Looper和MessageQueue会在UI线程创建时就存在,如果在子线程中就需要自己写Looper。

会出现这样一个警告,表示内存泄漏,leak是泄漏的意思。

private Handler mHandler=new Handler(Looper.myLooper()){

只需要写上Looper.myLooper()就不报警告,表示取主线程自己的Looper。

what用于区分是谁发的消息

arg1,arg2,obj相当于一个变量,用于标识,区分

sendMessage发送有消息的

sendEmptyMessage发送空消息,啥都没有,触发一下而已

下面是使用Handle机制进行延时6s后将信息显示到文本框上

package com.example.androidnetwork;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.view.View;
import android.widget.TextView;
import android.widget.Toast;
public class MainActivity2 extends AppCompatActivity {
    private TextView tvContent;
    private String strFromNet;
    //Handler处在主线程里,本身处理UI界面是没问题的
    private Handler mHandler=new Handler(Looper.myLooper()){
        @Override
        public void handleMessage(@NonNull Message msg) {
            //此时的参数msg就是我们传过去的message
            if(msg.what==0){
                String strData=(String)msg.obj;
                tvContent.setText(strData);
                Toast.makeText(MainActivity2.this, "主线程收到消息!", Toast.LENGTH_SHORT).show();
            }
        }
    };
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main2);
        tvContent = findViewById(R.id.tv_content);
    }
    public void start(View view) {
        //做一个耗时任务
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                String stringFromNet = getStrFromNet();
                //子线程中执行UI操作会报错
                //tvContent.setText(stringFromNet);
                Message message=new Message();
                message.what=0;
                message.obj=stringFromNet;
                mHandler.sendMessage(message);
            }
        });
        thread.start();
        Toast.makeText(this, "任务完成!", Toast.LENGTH_SHORT).show();
    }
    private String getStrFromNet() {
        //假装从网络上获取了一个字符串
        String result = " ";
        StringBuilder stringBuilder = new StringBuilder();
        //模拟一个耗时操作
        for (int i = 0; i < 100; i++) {
            stringBuilder.append("字符串" + i);
        }
        try {
            Thread.sleep(6000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        result = stringBuilder.toString();
        return result;
    }
}

其实在执行new Thread过程中就是一个异步的

比如:

public void start(View view) {
        //做一个耗时任务
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                String stringFromNet = getStrFromNet();
                //子线程中执行UI操作会报错
                tvContent.setText(stringFromNet);
            }
        });
        thread.start();
        Toast.makeText(this, "任务完成!", Toast.LENGTH_SHORT).show();
    }

主线程会先执行 Thread thread = new Thread(new Runnable() {和thread.start();Toast.makeText(this, “任务完成!”, Toast.LENGTH_SHORT).show();而 @Override public void run() {

String stringFromNet = getStrFromNet();tvContent.setText(stringFromNet);}

会当主线程执行到了thread.start();的时候子线程才会去执行

使用新线程计算质数

package com.example.androidnetwork;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;
import java.util.ArrayList;
import java.util.List;
public class MainActivity2 extends AppCompatActivity {
    public final static String UPPER_NUM = "upper";
    private EditText etNum;
    private CalThread mCalThread;
    class CalThread extends Thread {
        private Handler mHandler;
        @Override
        public void run() {
            Looper.prepare();
            mHandler = new Handler() {
                //定义处理消息的方法
                @Override
                public void handleMessage(@NonNull Message msg) {
                    if (msg.what == 0x123) {
                        int upper = msg.getData().getInt(UPPER_NUM);
                        List<Integer> nums = new ArrayList<>();
                        outer:
                        //计算从2开始,到upper的所有质数
                        for (int i = 2; i <= upper; i++) {
                            //用i除以从2开始,到i的平方根的所有数
                            int j = 2;
                            while (j <= Math.sqrt(i)) {
                                //如果可以整除,则表明这个数不是质数
                                if (i != 2 && i % j == 0) {
                                    continue outer;
                                }
                                j++;
                            }
                            nums.add(i);
                        }
                        //使用Toast显示统计出来的所在质数
                        Toast.makeText(MainActivity2.this, nums.toString(), Toast.LENGTH_SHORT).show();
                    }
                }
            };
            Looper.loop();
        }
    }
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main2);
        etNum=findViewById(R.id.et_num);
        mCalThread=new CalThread();
        //启动新线程
        mCalThread.start();
    }
    //为按钮的点击事件提供事件处理方法
    public void cal(View view){
        Log.d("====", "cal: +ddasdsadas");
        //创建消息
        Message msg=new Message();
        msg.what=0x123;
        Bundle bundle=new Bundle();
        bundle.putInt(UPPER_NUM,Integer.parseInt(etNum.getText().toString()));
        msg.setData(bundle);
        //向新线程中的Handler发送消息
        mCalThread.mHandler.sendMessage(msg);
    }
}

在子线程(或新线程处理Handler消息的方法)

1.调用Looper的prepare()方法为当前线程创建Looper对象,创建Looper对象时,它的构造器会创建与之配套的MessageQueue。

2.有了Looper之后,创建Handler子类的实例,重写handlerMessage()方法,该方法负责处理来自其他线程的消息。

3.调用Looper的loop()方法启动Looper。

加载全部内容

相关教程
猜你喜欢
用户评论