Android多线程和常用异步处理技术

最新推荐文章于 2023-07-05 16:45:51 发布

一只敲代码的嗷呜

最新推荐文章于 2023-07-05 16:45:51 发布

阅读量3.3k

点赞数 2

分类专栏： Java语言文章标签： android android studio java

本文链接：https://blog.csdn.net/m0_66309026/article/details/123727714

版权

Java语言专栏收录该内容

11 篇文章 3 订阅

订阅专栏

Android多线程和常用异步处理技术

一、Android多线程概述

1.概述：表示一个程序的多段语句同时执行，但并不等于多次启动一个程序，操作系统也不会把每个线程当作独立的进程来对待。
2.线程和进程的区别：
①两者粒度不同，是两个不同层次上的概念。进程是由操作系统来管理，而线程则是在一个程序（进程）内；
②不同进程的代码和状态都是完全独立的，而一个程序内的多线程是共享同一块内存空间和同一组系统资源，有可能相互影响；
③线程本身的数据通常只有寄存器数据，以及一个程序执行时使用的堆栈，所以线程的切换比进程切换的负担要小。

二、常用异步处理技术

1.Handler+Thread
处理较为复杂的线程间通信及消息处理
2.AsyncTask
轻量级基于多线程的进行后台异步工作处理
3.HandlerThread
继承了Thread，实际上是一个使用Looper、Handler的线程，内部维护了一个消息队列，避免多次创建和销毁子线程来进行操作
4.IntentService
用于处理Intent类型的异步任务请求

接下来我将给出应用前三种方式的代码
实验最终效果如图
在这里插入图片描述

（一）Handler+Thread

1.这三种方式的xml布局文件都完全一样，在这里我统一给出

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout 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"
    android:orientation="vertical"
    tools:context=".MainActivity">

    <TextView
        android:id="@+id/tv1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:visibility="visible"
        android:text="未开始下载"/>

    <Button
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="开始下载" />

    <ProgressBar
        android:id="@+id/progressBar"
        style="?android:attr/progressBarStyleHorizontal"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:max="100"
        android:visibility="gone"/>

</LinearLayout>

2.在Activity文件中定义消息处理Handler类对象，并重写handlerMessage()方法，通过Message传来的值更新进度；
Button单击处理事件（创建新的线程执行耗时操作，并将消息msg传递给handler对象）

package edu.hbfu.thread;

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.Button;
import android.widget.ProgressBar;
import android.widget.TextView;
import android.widget.Toast;

public class MainActivity extends AppCompatActivity {
    TextView textView;//声明变量
    Button button;
    ProgressBar progressBar;
    int pbValue;//整型变量，progressBar进度值

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        textView = findViewById(R.id.tv1);//赋值
        button = findViewById(R.id.button);
        progressBar = findViewById(R.id.progressBar);

        final Handler handler = new Handler(Looper.getMainLooper()){//新建Handler类的实例对象
            @Override
            public void handleMessage(@NonNull Message msg) {//重写handleMessage()方法
                super.handleMessage(msg);

                if (msg.arg2 == 0) {//通过Message传递过来的值进行进度条的进度更新
                    progressBar.setProgress(pbValue);
                    textView.setText("已下载"+msg.arg1+"%");
                } else {
                    Toast.makeText(MainActivity.this, "加载完成", Toast.LENGTH_SHORT).show();
                    textView.setText("恭喜，下载完成");
                    progressBar.setVisibility(View.GONE);//加载完成后进度条消失
                }
            }
        };

        button.setOnClickListener(new View.OnClickListener() {//匿名内部类，事件监听
            @Override
            public void onClick(View view) {

                textView.setVisibility(View.VISIBLE);//设置各组件可见性
                progressBar.setVisibility(View.VISIBLE);
                progressBar.setProgress(0);//设置进度条初始值为0

                new Thread(new Runnable() {//新建非UI线程，匿名内部类
                    @Override
                    public void run() {

                        pbValue = 0;//初始值为0
                        while (true){//永真循环

                            pbValue+= (int)(Math.random()*10);//产生随机小数*10，赋给pbValue
                            try {
                                Thread.sleep(100);//休眠100毫秒，模拟耗时操作
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                            Message message = Message.obtain();//获取消息池中的消息对象
                            if (pbValue<progressBar.getMax()){
                                message.arg1 = pbValue;//更新后的进度值
                                message.arg2 = 0;//代表没有下载完成
                                handler.sendMessage(message);//发送消息
                            } else{
                                message.arg1 = progressBar.getMax();
                                message.arg2 = 1;//代表下载完成
                                handler.sendMessage(message);//发送消息
                                break;//退出循环
                            }

                        }

                    }
                }).start();//线程启动

            }
        });

    }
}

总结
Handler类实现步骤
1.创建Handler对象
2.子线程中发送消息
3.handler中捕获所需消息，实现相应

（二）AsyncTask

1.AsyncTask是Android提供的一个助手类，它对Thread和Handler进行了封装，方便我们使用；
Android之所以提供AsyncTask这个类，就是为了方便在后台线程中执行操作，然后将结果发送给主线程，从而在主线程中进行UI更新等操作；
在使用AsyncTask时，我们无需关注Thread和Handler，AsyncTask内部会对其进行管理，这样我们就只需要关注于业务逻辑即可。

package edu.hbfu.asynctask;

import androidx.appcompat.app.AppCompatActivity;

import android.os.AsyncTask;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.ProgressBar;
import android.widget.TextView;
import android.widget.Toast;

public class MainActivity extends AppCompatActivity {
    TextView textView;//声明变量
    Button button;
    ProgressBar progressBar;
    int pbValue;//整型变量，progressBar进度值

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        textView = findViewById(R.id.tv1);//赋值
        button = findViewById(R.id.button);
        progressBar = findViewById(R.id.progressBar);

        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                new MyTask().execute();//新建MyAsyncTask类对象，并调用其execute()方法
            }
        });

    }

    class MyTask extends AsyncTask<String, Integer, String> {//分别代表：执行后台任务传递的参数、更新的进度值的类型（都是整形） 、返回结果类型
        @Override
        protected void onPreExecute() {//前期准备，初始化工作
            super.onPreExecute();
            textView.setVisibility(View.VISIBLE);
            progressBar.setVisibility(View.VISIBLE);
            progressBar.setProgress(0);//设置进度条初始值为0
        }

        @Override
        protected String doInBackground(String... strings) {

            pbValue = 0;//初始值为0
            while (pbValue < progressBar.getMax()) {

                pbValue += (int) (Math.random() * 10);//产生随机小数*10，赋给pbValue
                try {
                    Thread.sleep(100);//休眠100毫秒，模拟耗时操作
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                publishProgress(pbValue);//发布进度

            }
            return "恭喜，下载完成";
        }

        @Override
        protected void onProgressUpdate(Integer... values) {//进度实时更新
            super.onProgressUpdate(values);
            textView.setText("已下载"+values[0]+"%");
            progressBar.setProgress(values[0]);
        }

        @Override
        protected void onPostExecute(String s) {//收尾工作
            super.onPostExecute(s);
            Toast.makeText(MainActivity.this, "加载完成", Toast.LENGTH_SHORT).show();
            textView.setText(s);
            progressBar.setVisibility(View.GONE);//加载完成后进度条消失
        }

    }
    /* AsyncTask中各方法执行说明：
    1.当Task启动，首先执行onPreExecute()方法（UI Thread，进行UI组件初始状态设置），
      该方法执行完毕立即调用doInBackground()方法。
    2.doInBackground()方法在onPreExecute()执行之后执行---非UI Thread。
    3.publishProgress()方法在后台执行，主要用于发布进度，
      该方法调用，则onProgressUpdate()方法被回调，否则不会回调onProgressUpdate()方法。
    4.onProgressUpdate()方法只有在publishProgress()方法被调用后，才会被系统回调---UI Thread，
      更新UI组件。
    5.onPostExecute()方法在doInBackground()方法执行完毕后被调用----UI Thread，
      进行UI组件更新的后续操作*/

//    新建AsyncTask的子类并重写相关的方法：
//    1.在onPreExecute()中设置各组件的可见性及进度条的初始值
//    2.在doInBackground()方法中，每隔100ms通过publishProgress()方法发布进度条进度值
//    3.在onProgressUpdate()方法中，设置UI组件的进度更新值，值取自values[0]
//    4.在onPostExecute()方法中，设置下载完成状态时UI组件的属性
}

总结步骤
1.新建MyTask类继承自AsyncTask类并重写其相关方法onPreExecute()、doInBackground()、onProgressUpdate()、onPostExecute()
2.在button按钮的事件监听中新建MyTask类对象并运行

（三）HandlerThread

1.当系统有多个耗时任务需要执行时，每个任务都会开启一个新线程去执行耗时任务，这样会导致系统多次创建和销毁线程，从而影响性能。为此，Google提供了HandlerThread类，在线程中创建一个Looper循环器，让Looper轮询消息队列，当有耗时任务进入队列时，则不需要开启新线程，在原有的线程中执行耗时任务即可，否则线程阻塞。
2.HandlerThread继承于Thread，所以它本质就是一个Thread。与普通Thread的差别就在于，在内部直接有了Looper的实现，这是Handler消息机制必不可少的。有了自己的Looper，可以在自己的线程中分发和处理消息。

package edu.hbfu.handlerthread;

import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import android.view.View;
import android.widget.Button;
import android.widget.ProgressBar;
import android.widget.TextView;
import android.widget.Toast;

public class MainActivity extends AppCompatActivity {
    TextView textView;//声明变量
    Button button;
    ProgressBar progressBar;
    int pbValue;//整型变量，progressBar进度值
    private HandlerThread handlerThread;
    private  Handler threadHandler, uiHandler;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        textView = findViewById(R.id.tv1);//赋值
        button = findViewById(R.id.button);
        progressBar = findViewById(R.id.progressBar);

        handlerThread = new HandlerThread("handler-thread");//线程创建，传入参数的作用主要是标记当前线程的名字，可以任意字符串
        handlerThread.start();//线程启动

        threadHandler = new Handler(handlerThread.getLooper()) {//创建工作线程（子线程），获得子线程的Looper循环器，跟handlerThread绑定
            @Override
            public void handleMessage(@NonNull Message msg) {//重写handleMessage
                super.handleMessage(msg);
                /*switch (msg.what) {//进行耗时操作
                    case 0:
                        break;
                        default:
                            break;
                }*/
                if (msg.what==0) {//进行耗时操作
                    pbValue = 0;//初始值为0
                    while (pbValue<progressBar.getMax()) {

                        pbValue += (int) (Math.random() * 10);//产生随机小数*10，赋给pbValue
                        try {
                            Thread.sleep(100);//休眠100毫秒，模拟耗时操作
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //通过主线程（UI线程）Handler向主线程发送UI处理消息
                        Message message = uiHandler.obtainMessage();
                        message.arg1 = pbValue;
                        uiHandler.sendMessage(message);

                    }
                }
            }
        };

        uiHandler = new Handler(Looper.getMainLooper()) {//创建UI线程，与主线程的Looper循环器绑定
            @Override
            public void handleMessage(@NonNull Message msg) {//重写handleMessage进行UI处理
                super.handleMessage(msg);
                //进行UI处理操作
                if (pbValue<progressBar.getMax()) {//通过Message传递过来的值进行进度条的进度更新
                    progressBar.setProgress(pbValue);
                    textView.setText("已下载"+msg.arg1+"%");
                }else {
                    Toast.makeText(MainActivity.this, "加载完成", Toast.LENGTH_SHORT).show();
                    textView.setText("恭喜，下载完成");
                    progressBar.setVisibility(View.GONE);//加载完成后进度条消失
                }
            }
        };

        button.setOnClickListener(new View.OnClickListener() {//匿名内部类，事件监听
            @Override
            public void onClick(View view) {

                textView.setVisibility(View.VISIBLE);//设置各组件可见性
                progressBar.setVisibility(View.VISIBLE);
                progressBar.setProgress(0);//设置进度条初始值为0

                threadHandler.sendEmptyMessage(0);

            }
        });

    }
}

总结HandlerThread使用步骤
1.创建HandlerThread实例对象并启动线程
2.创建工作线程（子线程）threadHandler对象，并重写handleMessage()方法
3.创建UI线程（主线程）uiHandler对象，并重写handleMessage()进行UI处理
4.通过主线程uiHandler向主线程发送UI处理消息

一只敲代码的嗷呜

关注

2
点赞
踩
17

收藏

觉得还不错? 一键收藏
打赏
0
评论
Android多线程和常用异步处理技术

Android多线程和常用异步处理技术一、Android多线程概述1.概述：表示一个程序的多段语句同时执行，但并不等于多次启动一个程序，操作系统也不会把每个线程当作独立的进程来对待。2.线程和进程的区别：①两者粒度不同，是两个不同层次上的概念。进程是由操作系统来管理，而线程则是在一个程序（进程）内；②不同进程的代码和状态都是完全独立的，而一个程序内的多线程是共享同一块内存空间和同一组系统资源，有可能相互影响；③线程本身的数据通常只有寄存器数据，以及一个程序执行时使用的堆栈，所以线程的切换比进程切
复制链接

扫一扫