Android多线程-AsyncTask的使用和问题(取消,并行和串行,屏幕切换)

原创 2017年05月27日 15:45:17

AsyncTask是Android提供的一个执行异步工作的类,内部其实是运用了线程池和Handler来进行异步任务的执行和与主线程的交互。AsyncTask只是一个辅助类,适合执行时间短的异步任务。

本文基于Android7.0的代码来说的。

原文地址 http://blog.csdn.net/qq_25806863/article/details/72782050

示例

AsyncTask的使用方法是很简单的。就做一个简单的进度条。

布局是这样的:

里面有一个进度条ProgressBar pb1,开始按钮Button btn1,停止按钮Button stop1

然后实现一个AsyncTask,通过构造方法接收一个ProgressBar和Button进行操作:

public class MyAsyncTask extends AsyncTask<String, Integer, String> {
    private String TAG = this.getClass().getSimpleName();

    Button btn;
    ProgressBar pb;

    public MyAsyncTask(Button btn, ProgressBar pb) {
        this.btn = btn;
        this.pb = pb;
    }

    @Override
    protected String doInBackground(String... params) {
        String result = "完成";
        for (int i = 1; i <= 10; i++) {
            try {
                Log.i(TAG, "doInBackground: "+i);
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            publishProgress(i);
        }

        return result;
    }

    @Override
    protected void onPreExecute() {
        Log.i(TAG, "onPreExecute: 准备工作");
    }

    @Override
    protected void onPostExecute(String s) {
        btn.setText(s);
        Log.i(TAG, "onPostExecute: 回调");
    }

    @Override
    protected void onProgressUpdate(Integer... values) {
        pb.setProgress(values[0]);
    }
}

然后给两个按钮添加点击事件:

MyAsyncTask task1
task1 = new MyAsyncTask(btn1, pb1);
btn1.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        Log.i(TAG, "onClick: 开始1");
        task1.execute();
    }
});
stop1.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        Log.i(TAG, "onClick: 停止1");
        task1.cancel(true);
    }
});

1.构造参数

AsyncTask定义了三个泛型参数,在继承的时候必须填写。例如上面的AsyncTask<String, Integer, String>

在源码中定义是:

参数含义在下面的方法中会具体用到,先大致了解一下:

  • Params 启动任务的时候输入的参数类型,一般都是String类型,如填个网址啥的。 上面示例中就是String类型。
  • Progress 用来更新进度的类型。表示任务执行的进度的类型。 示例用的进度条,所以选择Integer类型。
  • Result 后台任务执行完后返回的结果, 示例中返回的也是String类型。

2.重写方法

要使用AsyncTask最少需要重写方法doInBackground。因为只有这个方法是抽象方法。

这个方法是在后台线程执行的。可以看到使用的参数类型Params就是在构造时定义的第一个类型。而返回的类型Result就是定义的第三个类型。

初次之外一般为了对任务流程进行控制还会重写下面几个方法onPreExecute,onPostExecute,onProgressUpdate

下面几个方法在AsyncTask中是空的,而且都要求在主线程中执行。

@MainThread
protected void onPreExecute() {
}
@MainThread
protected void onPostExecute(Result result) {
}
@MainThread
protected void onProgressUpdate(Progress... values) {
}
  • onPreExecute() 在异步任务开始前做的操作,
  • onPostExecute(Result result) 后台任务执行完后,通过这个方法能拿到任务返回的结果,进行处理。
  • onProgressUpdate(Progress… values) 这个表示进度变化,参数类型是构造时的第二个类型Progress。进度应该是随着任务的执行实时更新的,但是这个方法要在主线程中运行,而doInBackground是在子线程中运行,所以不能直接在doInBackground中调用onProgressUpdate方法,而是通过调用publishProgress(Progress... values)来间接调用这个方法。

3.开始任务

AsyncTask的开始有下面三种方法:

execute(Params... params)
executeOnExecutor(Executor exec,Params... params) 
execute(Runnable runnable)
  • execute(Params… params) 这个就是在示例中使用的开始任务的方式,传入指定的参数,参数类型要和构造时定义的第一个参数类型Params一样。参数可以为空的,那么在方法doInBackground(Params... params)中的参数也是空的。使用默认的线程池执行任务,会按流程执行onPreExecute,doInBackground(Params... params),onPostExecute(Result result)等方法。

  • executeOnExecutor(Executor exec,Params… params) 如果默认的线程池不能满足你的要求,可以用这个方法用指定线程池来执行任务。流程跟上面是一样的。

  • execute(Runnable runnable) 这个方法传进来的是一个Runnable类型,方法中只有一行代码sDefaultExecutor.execute(runnable)就是用默认的线程池直接执行任务,就是使用线程池了,跟前面那些重写的方法没关系。

4.停止任务

要停止任务可以调用下面的方法:

public final boolean cancel(boolean mayInterruptIfRunning) {
    mCancelled.set(true);
    return mFuture.cancel(mayInterruptIfRunning);
}

下面是停止的演示:

取消也有一个回调方法可以重写,这里加上,也是运行在主线程中:

@Override
protected void onCancelled() {
    Log.i(TAG, "onCancelled: 取消任务");
    btn.setText("取消了");
}

取消的问题

cancel方法被调用后,onPostExecuteonProgressUpdate方法都不会再调用了。而doInBackground方法却会一直执行下去,也就是后台任务会继续执行。

cancel(boolean mayInterruptIfRunning)这个参数mayInterruptIfRunning文档中表示是否应该立即终止doInBackground中的任务。

然而实际用起来就不是那样的了,无论我们传的是true还是false,而AsyncTask的cancle方法只是打上了一个取消的标记。并不是直接终止任务。如果是true,则会调用一下后台线程的interrupt方法。

当调用了cancle方法后,调用isCancelled方法会返回true。在doInBackground中应该调用isCancelled来检查当前任务是否被取消,以便及时终止任务。

AsyncTask设计成这样就是为了方便更新主线程界面的,所以对用户来说,在调用了cancle方法后,后台的任务就不会在影响到主线程的界面变化了,因为后续的跟主线程交互的方法都不会再执行了。,也可以说是取消了。

而真的要及时取消doInBackground的继续运行则需要在这个方法中进行一些判断。

不做处理

不做处理也就是在doInBackground中不做判断,像下面这样。看一下输出的日志。当然界面的进度条都会停住,只要看doInBackground有没有在点击停止按钮后停下来。

protected String doInBackground(String... params) {
        String result = "完成";
        for (int i = 1; i <= 10; i++) {
            try {
                Log.i(TAG, "doInBackground: "+i);
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            publishProgress(i);
        }
        return result;
    }
  • cancle(true):

  • cancle(false):

可以看到区别是,当值为true的时候,后台线程也会跑完。但是会调用子线程的interrupt方法,而这个现在正在sleep,所以会引发InterruptedException.

而值为false的时候,没有任何变化,后台线程继续跑完。

做处理

1. 判断isCancelled

在不同的运行节点判断这个方法的值:

@Override
protected String doInBackground(String... params) {
    String result = "完成";
    for (int i = 1; i <= 10; i++) {
        try {
            if (isCancelled()){
                Log.i(TAG, "doInBackground: 被标记停止了");
                break;
            }
            Log.i(TAG, "doInBackground: "+i);
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        publishProgress(i);
    }
    return result;
}

这时调用cancle(false):

调用cancle(true)只是会多打印一个异常,一样会停止。

2.抓异常

因为调用cancle(true)的时候有可能会抛出异常,如这个例子中的InterruptedException,因此可以通过异常捕捉来实现。

@Override
protected String doInBackground(String... params) {
    String result = "完成";
    for (int i = 1; i <= 10; i++) {
        try {
            Log.i(TAG, "doInBackground: "+i);
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
            Log.i(TAG, "doInBackground: 捕捉到异常,退出");
            break;
        }
        publishProgress(i);
    }
    return result;
}

这时调用cancle(true):

并行和串行

据说AsyncTask的任务是并行还是串行执行在不同Android版本有所变化,但是从API13开始,AsyncTask的任务执行都是串行的。

何为串行,比如有下面的界面:

有两个task

private ProgressBar pb1;
private ProgressBar pb2;
private Button btn1;
private Button btn2;
private Button stop1;
private Button stop2;
private MyAsyncTask task1, task2;
@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView();
        task1 = new MyAsyncTask(btn1, pb1);
        task2 = new MyAsyncTask(btn2, pb2);java
        btn1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.i(TAG, "onClick: 开始1");
                task1.execute();
            }
        });
        btn2.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.i(TAG, "onClick: 开始2");
                task2.execute();
            }
        });
        stop1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.i(TAG, "onClick: 停止1 ");
                task1.cancel(true);
            }
        });
        stop2.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.i(TAG, "onClick: 停止2");
                task2.cancel(false);
            }
        });
    }

在上面的MyAstncTask中,后台任务要执行10秒。

这里为了区分,打印开始按钮的名字来区分:

public class MyAsyncTask extends AsyncTask<String, Integer, String> {
    private String TAG = this.getClass().getSimpleName();

    Button btn;
    ProgressBar pb;
    String name;
    public MyAsyncTask(Button btn, ProgressBar pb) {
        this.btn = btn;
        this.pb = pb;
        name = btn.getText().toString();
    }

    @Override
    protected String doInBackground(String... params) {
        String result = "完成";
        for (int i = 1; i <= 10; i++) {
            try {
                Log.i(TAG, "doInBackground: "+name+" "+i);
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
                Log.i(TAG, "doInBackground: 捕捉到异常,退出");
                break;
            }
            publishProgress(i);
        }

        return result;
    }

    @Override
    protected void onPreExecute() {
        Log.i(TAG, "onPreExecute: 准备工作 "+name);
    }

    @Override
    protected void onPostExecute(String s) {
        btn.setText(s);
        Log.i(TAG, "onPostExecute: 回调 "+name);
    }

    @Override
    protected void onProgressUpdate(Integer... values) {
        pb.setProgress(values[0]);
    }


    @Override
    protected void onCancelled() {
        Log.i(TAG, "onCancelled: 取消任务 "+name);
        btn.setText("取消了");
    }
}

在点击第一个开始按钮之后点击第二个开始按钮,效果:

打印日志:

虽然点击了开始2,但是依然等第一个任务完成了才开始第二个任务。

想要让任务并行执行怎么办呢?其实他之所以会串行执行任务,是因为内部默认的线程池中将任务进行了排队,保证他们一个一个来。只要我们换个满足要求的线程池来执行任务就行了。AstncTask内部就有一个线程池AsyncTask.THREAD_POOL_EXECUTOR可以使用。当然,用Executors来创建也行。

然后将开始任务的execute(Params... params)方法改为executeOnExecutor(Executor exec,Params... params).这里用AsyncTask.THREAD_POOL_EXECUTOR.

task1.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
task2.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);

效果:

日志:

屏幕横竖屏切换

使用AsyncTask的时候,在屏幕切换也会出现问题。

画面是这样的:

日志是这样的,动图中也能看见:

虽然屏幕切换后,任务也在执行,也在不停地调用更新进度条的方法,最后也执行了onPostExecute方法,但是界面上就是什么变化都没有。

因为在横竖屏切换的时候,Activity会销毁重建,所以AsyncTask所持有的引用就不是新建的Activity的控件了,新的Activity就不会变化了。

其中一种解决方法

很简单,加上这句就行了。

这时屏幕怎么切换都没事


版权声明:

相关文章推荐

Android AsyncTask多线程详解

  • 2015-04-07 11:36
  • 1003KB
  • 下载

Android多线程问题—— AsyncTask机制

Android中,为了实现UI线程和worker线程之间的通信,设计了两种方式:Handler机制和AsyncTask机制。 AsyncTask:异步任务,它是一个多线程编程的框架。从字面上来说,就...

struts2的多线程访问问题(特定参数下只能串行访问action)

以前一直都是理所当然的认为浏览器发起一个请求到后台action,肯定是创建一个新线程并创建一个新类来为这个请求服务,其中的想法也比较混乱却没有理会。 直到近期遇到了一个新的需求要做高并发的时候抢购一个...

Android多线程分析之五:使用AsyncTask异步下载图像

在本系列文章的第一篇《Android多线程分析之一:使用Thread异步下载图像》中,曾演示了如何使用 Thread 来完成异步任务。Android 为了简化在 UI 线程中完成异步任务(毕竟 UI ...

Android 多线程 AsyncTask的使用

最近项目中频繁的使用Handler,我认为不好,所以用了另一种异步操作的方法,那就是 AsyncTask!

android多线程 异步请求 AsyncTask使用心得

android的多线程总是比较头疼的事情,然而多线程又分为同步机制和异步机制,根据业务的需要我们选择相应的机制 最近有个需求是根据包裹上的地址获得地址的经纬度,然后在高德地图上标注包裹的位置,刚开...

Android多线程通讯之AsyncTask使用详解

AsyncTask是Android提供的一个助手类,它对Thread和Handler进行了封装,方便我们使用。Android之所以提供AsyncTask这个类,就是为了方便我们在后台线程中执行操作,然...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)