Android AsyncTask

最新推荐文章于 2020-01-17 15:31:37 发布

置顶吴庆森

最新推荐文章于 2020-01-17 15:31:37 发布

阅读量337

点赞数 2

分类专栏： Android 理论知识多线程应用的常用方法文章标签： AsyncTask Android AsyncTask 异步任务

本文链接：https://blog.csdn.net/wuqingsen1/article/details/82965580

版权

Android 理论知识同时被 2 个专栏收录

57 篇文章 2 订阅

订阅专栏

多线程应用的常用方法

5 篇文章 0 订阅

订阅专栏

多线程的应用在Android开发中是非常常见的，常用方法主要有：

1.继承Thread类（继承 Thread 类和实现 Runnable 接口的区别）

2.实现 Runnable 接口（继承 Thread 类和实现 Runnable 接口的区别）

3.Handler

4.AsyncTask（异步任务）

5.HandlerThread

今天就来看一下关于 AsyncTask（异步任务）的理解和用法。

1.定义

Android 为我们提供的一个处理异步任务的类；
是一个抽象类，使用时需实现子类；

2.作用

实现 UI 线程和后台线程进行通讯，后台线程执行异步任务，并且把结果返回给 UI 线程。

3.特点

不需要使用“任务线程+ Handler ”的复杂组合；
不适合长时间的后台工作，长线程建议使用线程池等技术；
采用线程池的缓存线程 + 复用线程，避免频繁创建销毁线程所带来的系统资源开销；

4.构建 AsyncTask 子类的泛型参数

public abstract class AsyncTask<Params, Progress, Result> {...}

继承 AsyncTask 需要指定三个泛型参数：

Params：开始时传入的参数类型，对应方法 excute() 中传递的参数；

Progress：执行过程中，返回下载进度值的类型；

Result：执行完成后，返回的结果类型，与方法 doInBackground() 的返回值类型保持一致；

5.五大方法、三大步骤

5.1 五大方法

在使用 AsyncTask 时需要记住 AsyncTask 子类五个重要的回调方法，如下图：

方法名	作用	示例
onPreExecute()	执行任务之前会调用执行任务前的操作	`@Override protected void onPreExecute() { //执行前显示提示 textView.setText("加载中..."); }`
doInBackground(Params p)	（重要方法必须重写）接收传入的参数进行耗时操作(执行任务) 返回执行结果执行任务时调用不可进行更新 UI 的操作	`@Override protected String doInBackground(String... strings) { try { //模拟耗时 Thread.sleep(50); } catch (InterruptedException e) { e.printStackTrace(); } return null; }`
onProgressUpdate(Progress p)	主线程显示进度	`@Override protected void onProgressUpdate(Void... values) { textView.setText("加载中--" + values[0] + "%"); }`
onPostExecute(Result r)	接受执行结果将执行结果显示到UI	`@Override protected void onPostExecute(String s) { textView.setText("加载完成"); }`
onCancelled()	取消任务	`@Override protected void onCancelled() { textView.setText("任务被取消"); }`

5.2 三大步骤

看完 AsyncTask 中五个重要的回调方法之后，再来看一下 AsyncTask 三个重要的使用步骤

步骤一：创建 AsyncTask 子类，实现其中的核心方法；
步骤二：创建 AsyncTask 子类的实例对象；
步骤三：手动调用 execute(Params... params) 方法开始执行异步任务；

6.AsyncTask 使用实例一：加载网络图片

这是下面两个实例的下载链接

看完 AsyncTask 三个使用步骤之后，下面将通过这三个步骤来写一个加载网络图片的实例，下面是效果图：

下面就来看代码吧，先添加网络权限：

<uses-permission android:name="android.permission.INTERNET" />

然后下面是我 xml 文件中的代码：

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.example.qd.handlerlizi.MainActivity">

    <TextView
        android:id="@+id/textView"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_above="@+id/imageView"
        android:gravity="center"
        android:textSize="18dp" />

    <ImageView
        android:id="@+id/imageView"
        android:layout_width="150dp"
        android:layout_height="150dp"
        android:layout_centerInParent="true"
        android:textColor="@color/colorAccent" />

    <ProgressBar
        android:id="@+id/progressBar"
        android:layout_width="30dp"
        android:layout_height="30dp"
        android:layout_centerInParent="true"
        android:visibility="gone" />

    <Button
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@+id/imageView"
        android:layout_centerInParent="true"
        android:layout_marginTop="15dp"
        android:text="点我加载" />

</RelativeLayout>

下面是我 Activity 中主要的代码：

    private String Url = "http://static.gamemm.com/upload/avatar/201801/29/12812_1517188003.jpg";
    private ProgressBar progressBar;
    private ImageView imageView;
    private TextView textView;
    private MyTask myTask;
    private Button button;

    /**
     * 步骤1：创建AsyncTask子类
     */
    class MyTask extends AsyncTask<String, Void, Bitmap> {
        // 方法1：onPreExecute（）写执行任务前的操作
        @Override
        protected void onPreExecute() {
            super.onPreExecute();
            //显示进度条
            progressBar.setVisibility(View.VISIBLE);
            textView.setText("正在加载");
        }

        // 方法2：doInBackground（）写耗时操作
        @Override
        protected Bitmap doInBackground(String... strings) {
            String url = strings[0];
            Bitmap bitmap = null;
            URLConnection connection;
            InputStream is;
            try {
                connection = new URL(url).openConnection();
                is = connection.getInputStream();
                //模拟耗时
                Thread.sleep(2000);
                BufferedInputStream bis = new BufferedInputStream(is);
                //通过decodeStream方法解析输入流
                bitmap = BitmapFactory.decodeStream(bis);
                is.close();
                bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return bitmap;
        }

        // 方法3：onProgressUpdate（）显示进度
        @Override
        protected void onProgressUpdate(Void... values) {
            //在这个实例中没用到
        }

        // 方法4：onPostExecute（）将执行结果显示到UI组件
        @Override
        protected void onPostExecute(Bitmap bitmap) {
            //隐藏进度条
            progressBar.setVisibility(View.GONE);
            //加载图片
            imageView.setImageBitmap(bitmap);
            textView.setText("加载完成");
        }

        // 方法5：onCancelled() 取消状态
        @Override
        protected void onCancelled() {
          //在这里没用到
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_two);
        progressBar = findViewById(R.id.progressBar);
        imageView = findViewById(R.id.imageView);
        textView = findViewById(R.id.textView);
        button = findViewById(R.id.button);
        /**
         * 步骤2：创建AsyncTask子类的实例对象（即 任务实例）
         */
        myTask = new MyTask();
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                /**
                 * 步骤3：手动调用execute(Params... params) 从而执行异步线程任务
                 */
                myTask.execute(Url);
            }
        });
    }

上面的注释很清楚，完全是按照三个步骤来的，就不再说了；

7.AsyncTask 使用实例二：模拟进度条加载

下面的实例是使用 AsyncTask 模拟进度条的加载，下面是效果图：

我 xml 文件中的代码：

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.example.qd.handlerlizi.MainActivity"
    android:orientation="vertical"
    android:gravity="center">

    <TextView
        android:id="@+id/textView"
        android:layout_width="match_parent"
        android:layout_height="50dp"
        android:textColor="@color/colorPrimary"
        android:gravity="center"/>
    <ProgressBar
        android:id="@+id/progressBar"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        style="?android:attr/progressBarStyleHorizontal"
        android:progress="0"
        android:max="100"/>
    <Button
        android:id="@+id/button"
        android:text="点我加载"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />
    <Button
        android:id="@+id/cancel"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="取消"/>

</LinearLayout>

下面是我 Activity 中的代码：

    private TextView textView;
    private MyTask myTesk;
    private Button btnStart, btnCancel;
    private ProgressBar progressBar;

    /**
     * 步骤1：创建AsyncTask子类
     * AsyncTask<Params,Progress,Result>是一个抽象类,通常用于被继承.继承AsyncTask需要指定如下三个泛型参数:
     * Params:启动任务时输入的参数类型.
     * Progress:后台任务执行中返回进度值的类型.
     * Result:后台任务执行完成后返回结果的类型.
     * 此处指定为：输入参数 = String类型、执行进度 = Integer类型、执行结果 = String类型
     */
    private class MyTask extends AsyncTask<String, Integer, String> {
        // 方法1：onPreExecute（）
        // 作用：执行 线程任务前的操作
        @Override
        protected void onPreExecute() {
            //执行前显示提示
            textView.setText("加载中...");
        }

        // 方法2：doInBackground（）
        // 作用：接收输入参数、执行任务中的耗时操作、返回 线程任务执行的结果
        // 此处通过计算从而模拟“加载进度”的情况
        @Override
        protected String doInBackground(String... strings) {
            try {
                int count = 0;
                int length = 1;
                while (count < 99) {
                    count += length;
                    //模拟耗时
                    Thread.sleep(50);
                    // 可调用publishProgress（）显示进度, 之后将执行onProgressUpdate（）
                    publishProgress(count);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return null;
        }

        // 方法3：onProgressUpdate（）
        // 作用：在主线程 显示线程任务执行的进度
        @Override
        protected void onProgressUpdate(Integer... values) {
            progressBar.setProgress(values[0]);
            textView.setText("加载中--" + values[0] + "%");
        }

        // 方法4：onPostExecute（）
        // 作用：接收线程任务执行结果、将执行结果显示到UI组件
        @Override
        protected void onPostExecute(String s) {
            textView.setText("完成");
        }

        // 方法5：onCancelled()
        // 作用：将异步任务设置为：取消状态
        @Override
        protected void onCancelled() {
            textView.setText("已取消");
            progressBar.setProgress(0);
        }
    }

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

        textView = findViewById(R.id.textView);
        btnStart = findViewById(R.id.button);
        btnCancel = findViewById(R.id.cancel);
        progressBar = findViewById(R.id.progressBar);

        /**
         * 步骤2：创建AsyncTask子类的实例对象（即 任务实例）
         * 注：AsyncTask子类的实例必须在UI线程中创建
         */
        myTesk = new MyTask();
        //启动AsyncTask
        btnStart.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                /**
                 * 步骤3：手动调用execute(Params... params) 从而执行异步线程任务
                 * a. 必须在UI线程中调用
                 * b. 同一个AsyncTask实例对象只能执行1次，若执行第2次将会抛出异常
                 * c. 执行任务中，系统会自动调用AsyncTask的一系列方法：onPreExecute() 、doInBackground()、onProgressUpdate() 、onPostExecute()等
                 */
                myTesk.execute();
            }
        });
        //取消AsyncTask
        btnCancel.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                // 取消一个正在执行的任务,onCancelled方法将会被调用
                myTesk.cancel(true);
            }
        });
    }

看完上面的两个实例，应该对 AsyncTask 有所了解（这是两个实例的下载链接）。

更多内容戳我&

吴庆森

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Android AsyncTask

多线程的应用在Android开发中是非常常见的，常用方法主要有：1.继承Thread类（继承 Thread 类和实现 Runnable 接口的区别）2.实现 Runnable 接口（继承 Thread 类和实现 Runnable 接口的区别）3.Handler4.AsyncTask（异步任务）5.HandlerThread今天就来看一下关于 AsyncTask（异步任务）的...
复制链接

扫一扫