Android 从零开始打造异步处理框架

最新推荐文章于 2023-04-13 20:09:56 发布
最新推荐文章于 2023-04-13 20:09:56 发布
阅读量227 收藏
点赞数
分类专栏： android 文章标签： android asynctask 线程 异步

转载请标明出处：http://www.cnblogs.com/zhaoyanjun/p/5995752.html
本文出自【赵彦军的博客】

概述

在Android中会使用异步任务来处理耗时操作，避免出现界面卡顿的问题，当然到目前为止可以使用的异步任务框架有很多，比如：

  • 直接 new Thread()
  • 用Android自带的AsyncTask
  • 用RxJava
  • 等等

今天我们就来自己尝试写一个异步任务处理框架，代码的设计思路参考AsyncTask

封装尝试

既然是异步的框架，那么肯定是在子线程中，所以第一步我们用自定义的ThreadTask继承Thread. 并且重写里面的run方法。

package com.zyj.app;

/**
 * Created by ${zyj} on 2016/10/17.
 */

public class ThreadTask extends Thread {

    @Override
    public void run() {
        super.run();
    }
}

然后子线程需要把处理结果回调给主线程，我们需要定义3个方法：

  • onStart 任务开始之前调用，运行在主线程。可以做显示进度条或者加载动画。
  • onDoInBackground 异步任务执行，运行在子线程。可以做耗时操作。
  • onResult 异步任务处理的结果，运行在主线程。

onDoInBackground这个方法是要在子类中实现的，所以要写成抽象的方法，那么ThreadTask类自然也要写成抽象类。同时这个方法会返回异步处理结果，这个结果的类型需要写成泛型，以便在子类中灵活运用。

package com.zyj.app;

import android.support.annotation.MainThread;
import android.support.annotation.WorkerThread;

/**
 * Created by ${zyj} on 2016/10/17.
 */

public abstract class ThreadTask<T> extends Thread  {

    @Override
    public void run() {
        super.run();
    }

    /**
     * 任务开始之前调用，运行在主线程
     */
    @MainThread
    public void onStart(){ }

    /**
     * 子线程中调用，运行在子线程
     * @return
     */
    @WorkerThread
    public abstract T onDoInBackground() ;

    /**
     * 子线程返回的结果，运行在主线程
     * @param t
     */
    @MainThread
    public void onResult( T t ){ }
}

另外子线程和主线程通信我们用的是Handler。Handler的初始化工作放在ThreadTask构造函数中完成。

    private Handler handler ;

    public ThreadTask(){
        handler = new Handler( Looper.getMainLooper()){
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                //在这里接收子线程发过来的消息
            }
        } ;
    }

最后还需要一个execute() 方法启动线程。在启动的前一刻最好调用Onstart方法。

    /**
     * 开始执行
     */
    public void execute(){
        onStart();
        start();
    }

最后一个完整的ThreadTask类是这样的

package com.zyj.app;

import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.support.annotation.MainThread;
import android.support.annotation.WorkerThread;

/**
 * Created by ${zyj} on 2016/10/17.
 */

public abstract class ThreadTask<T> extends Thread  {

    private Handler handler ;

    public ThreadTask(){
        handler = new Handler( Looper.getMainLooper()){
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                //在这里接收子线程发过来的消息
                onResult((T) msg.obj);
            }
        } ;
    }

    @Override
    public void run() {
        super.run();

        Message message = Message.obtain() ;
        message.obj = onDoInBackground() ;
        handler.sendMessage( message ) ;
    }

    /**
     * 任务开始之前调用，运行在主线程
     */
    @MainThread
    public void onStart(){ }

    /**
     * 子线程中调用，运行在子线程
     * @return
     */
    @WorkerThread
    public abstract T onDoInBackground() ;

    /**
     * 子线程返回的结果，运行在主线程
     * @param t
     */
    @MainThread
    public void onResult( T t ){ }


    /**
     * 开始执行
     */
    public void execute(){
        onStart();
        start();
    }
}

如何使用我们写好的框架？


    new ThreadTask<String>(){

        @Override
        public void onStart() {
            super.onStart();
            Log.d( "ThreadTask " , "onStart线程：" + Thread.currentThread().getName() ) ;
        }

        @Override
        public String onDoInBackground() {
            Log.d( "ThreadTask " , "onDoInBackground线程： " + Thread.currentThread().getName() ) ;

            //模拟耗时操作
            try {
                Thread.sleep( 3000 );
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "结果返回了";
        }

        @Override
        public void onResult(String s) {
            super.onResult(s);
            Log.d( "ThreadTask " , "onResult线程： " + Thread.currentThread().getName()  + " 结果：" + s ) ;
        }
    }.execute();

运行的结果：

ThreadTask: onStart线程：main
ThreadTask: onDoInBackground线程： Thread-229
ThreadTask: onResult线程： main 结果：结果返回了

Handler优化

到目前为止我们的框架初步就封装好了，但是有没有缺点呢，肯定是有的。首先每次创建一个ThreadTask的时候都会创建一个Handler,这显然不是我们想看到的。

  • 要保证Handler的实例的唯一性，可以用单例模式来获取Handler
    /**
     * 单例模式，保证handler只有一个实例
     * @return
     */
    private static Handler getHandler(){
        if ( handler == null ){
            synchronized ( MHandler.class ){
                if ( handler == null ){
                    handler= new MHandler( Looper.getMainLooper()) ;
                }
            }
        }
        return handler ;
    }
  • MHandler是我们自定义的一个Handler类
    private static class MHandler extends Handler {

        public MHandler( Looper looper ){
            super( looper );
        }

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            //在这里接收子线程发过来的消息
            ResultData resultData = (ResultData) msg.obj;
            resultData.threadTask.onResult( resultData.data );
        }
    }
  • ResultData是一个消息实体
  /**
     * handler发送数据的实体
     * @param <Data>
     */
    private static class ResultData<Data>{
        ThreadTask threadTask ;
        Data data ;
        public ResultData( ThreadTask threadTask  ,Data data  ){
            this.threadTask = threadTask ;
            this.data = data ;
        }
    }
  • 一个完整的代码实例
package com.zyj.app;

import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.support.annotation.MainThread;
import android.support.annotation.WorkerThread;

/**
 * Created by ${zyj} on 2016/10/17.
 */

public abstract class ThreadTask<T> extends Thread  {

    private static Handler handler ;

    public ThreadTask(){
    }

    @Override
    public void run() {
        super.run();
        Message message = Message.obtain() ;
        message.obj = new ResultData<T>( this , onDoInBackground() ) ;
        getHandler().sendMessage( message ) ;
    }

    /**
     * 任务开始之前调用，运行在主线程
     */
    @MainThread
    public void onStart(){ }

    /**
     * 子线程中调用，运行在子线程
     * @return
     */
    @WorkerThread
    public abstract T onDoInBackground() ;

    /**
     * 子线程返回的结果，运行在主线程
     * @param t
     */
    @MainThread
    public void onResult( T t ){ }


    /**
     * 开始执行
     */
    public void execute(){
        onStart();
        start();
    }

    /**
     * 单例模式，保证handler只有一个实例
     * @return
     */
    private static Handler getHandler(){
        if ( handler == null ){
            synchronized ( MHandler.class ){
                if ( handler == null ){
                    handler= new MHandler( Looper.getMainLooper()) ;
                }
            }
        }
        return handler ;
    }

    private static class MHandler extends Handler {

        public MHandler( Looper looper ){
            super( looper );
        }

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            //在这里接收子线程发过来的消息
            ResultData resultData = (ResultData) msg.obj;
            resultData.threadTask.onResult( resultData.data );
        }
    }

    /**
     * handler发送数据的实体
     * @param <Data>
     */
    private static class ResultData<Data>{
        ThreadTask threadTask ;
        Data data ;
        public ResultData( ThreadTask threadTask  ,Data data  ){
            this.threadTask = threadTask ;
            this.data = data ;
        }
    }
}

到现在已经解决了Handler多次创建的问题，那么这个ThreadTask本质上还是新建线程来运行异步任务，为了避免不断的创建线程，所以还需要一个线程池。

线程优化

  • 首选定义一个线程池，默认最大10个线程。
    /**
     * 线程池，创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
     */
    private static ExecutorService executorService = Executors.newFixedThreadPool( 15 ) ;
  • 修改run()方法。
    private void run() {
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                Message message = Message.obtain() ;
                message.obj = new ResultData<T>( ThreadTask.this , onDoInBackground() ) ;
                getHandler().sendMessage( message ) ;
            }
        });
    }
  • execute() 方法
    /**
     * 开始执行
     */
    public void execute(){
        onStart();
        run();
    }
  • 完整的代码实例
package com.zyj.app;

import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.support.annotation.MainThread;
import android.support.annotation.WorkerThread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Created by ${zyj} on 2016/10/17.
 */

public abstract class ThreadTask<T>  {

    private static Handler handler ;

    /**
     * 线程池，创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
     */
    private static ExecutorService executorService = Executors.newFixedThreadPool( 15 ) ;

    public ThreadTask(){

    }

    private void run() {
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                Message message = Message.obtain() ;
                message.obj = new ResultData<T>( ThreadTask.this , onDoInBackground() ) ;
                getHandler().sendMessage( message ) ;
            }
        });
    }

    /**
     * 任务开始之前调用，运行在主线程
     */
    @MainThread
    public void onStart(){ }

    /**
     * 子线程中调用，运行在子线程
     * @return
     */
    @WorkerThread
    public abstract T onDoInBackground() ;

    /**
     * 子线程返回的结果，运行在主线程
     * @param t
     */
    @MainThread
    public void onResult( T t ){ }


    /**
     * 开始执行
     */
    public void execute(){
        onStart();
        run();
    }

    /**
     * 单例模式，保证handler只有一个实例
     * @return
     */
    private static Handler getHandler(){
        if ( handler == null ){
            synchronized ( MHandler.class ){
                if ( handler == null ){
                    handler= new MHandler( Looper.getMainLooper()) ;
                }
            }
        }
        return handler ;
    }

    private static class MHandler extends Handler {

        public MHandler( Looper looper ){
            super( looper );
        }

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            //在这里接收子线程发过来的消息
            ResultData resultData = (ResultData) msg.obj;
            resultData.threadTask.onResult( resultData.data );
        }
    }

    /**
     * handler发送数据的实体
     * @param <Data>
     */
    private static class ResultData<Data>{
        ThreadTask threadTask ;
        Data data ;
        public ResultData( ThreadTask threadTask  ,Data data  ){
            this.threadTask = threadTask ;
            this.data = data ;
        }
    }
}

框架使用

  • 方式1
        new ThreadTask<String>(){

            @Override
            public String onDoInBackground() {
                return "我是线程";
            }
        }.execute();
  • 方式2
    new MyTask().execute();
    
    class MyTask extends ThreadTask<String> {

        @Override
        public void onStart() {
            super.onStart();
        }

        @Override
        public String onDoInBackground() {
            try {
                //模拟耗时操作
                Thread.sleep( 2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "ThreadTask" ;
        }

        @Override
        public void onResult(String s) {
            super.onResult(s);
        }
    }

凉幽
关注
专栏目录
android 异步操作框架
08-31
android 异步操作框架 优秀的开源异步框架
android从零开始
07-20
《Android从零开始》这份文档全面且深入地介绍了Android开发的基础知识，对于初学者来说，是一份极佳的学习资源。Android作为全球最流行的移动操作系统，它的应用开发领域广阔，涉及了从用户界面设计到系统级别的...
Android异步消息框架
mznewfacer的专栏
01-14 7598
自从rtsp从stagefright播放器移植到NuPlayer之后，你会发现相关的类中存在许多类似下面的代码： ================================11111111111111========================== NuPlayerDriver::NuPlayerDriver()      : mLooper(new ALooper) {
Android异步任务处理框架AsyncTask源码分析
废墟的树的专栏
07-20 5936
【转载请注明出处：http://blog.csdn.net/feiduclear_up CSDN 废墟的树】引言在平时项目开发中难免会遇到异步耗时的任务（比如最常见的网络请求）。遇到这种问题，我们可以自己通过Handler+Message+Thread/ThreadPool来构造一个异步耗时任务框架。当你下次项目中又遇到一个网络请求，你又不得不重写异步耗时任务处理框架。出于避免开发者重复搬砖工作，G
Android异步处理框架AsyncTask源码解析
Small_Lee的博客
05-02 3088
一.概述在Android开发中，我们进行异步处理一般会采用两种方式： 1.Thread +Handler 通常我们在Thread里面发送消息，然后在Handler的handleMessage方法里面去处理对应的任务，因为Android是不允许UI线程去更新UI的，这个时候我们可以采取这种方式 2.AsyncTask AsyncTask是Android为我们封装的一个轻量级的异步处理框架，其实
最新Android开发从零开始源码(更新到38)
09-23
在Android开发领域，从零开始学习意味着要掌握一系列的基础概念和技术。这个名为“最新Android开发从零开始源码”的资源提供了宝贵的实践材料，适合初学者和有经验的开发者用来巩固基础或探索新的开发技巧。这份源码...
从零开始Android游戏编程
04-12
本篇文章将基于"从零开始Android游戏编程"这一主题，详细讲解Android游戏开发的基础知识，带你一步步踏入游戏编程的世界。 首先，我们需要理解Android游戏开发的核心技术栈。这包括Java或Kotlin语言基础，因为这两...
从零开始Android游戏编程（第二版）
06-14
《从零开始Android游戏编程（第二版）》是一本针对初学者的专业教程，旨在帮助读者逐步掌握Android平台上的游戏开发技术。这本书详细介绍了如何利用Java语言和Android Studio开发出丰富多彩的游戏应用。以下是从该书...
android：从零开始+35小时的完整课程对android进行编程
02-28
这个"android：从零开始+35小时的完整课程对android进行编程"显然是一门深入浅出的教程，旨在帮助初学者快速掌握Android应用开发的核心技能。下面将详细阐述Android开发的基础知识和关键点，以及与Java语言的关联。 ...
Android最基本的异步网络请求框架
09-02
主要为大家详细介绍了Android最基本的异步网络请求框架，感兴趣的小伙伴们可以参考一下
android异步任务框架源码
12-28
一个异步任务的框架，开发者直接往其中塞代码就可以
Android-Anchors是一个基于图结构支持同异步依赖任务初始化Android启动框架
08-13
其锚点提供 "勾住" 依赖的功能，能灵活解决初始化过程中复杂的同步问题。参考 alpha 并改进其部分细节, 更贴合 Android 启动的场景, 同时支持优化依赖初始化流程, 自动选择较优的路径进行初始化。
android异步调用,一个Android异步调用的简单框架
weixin_28865303的博客
05-27 180
1 异步需要执行的函数，完成需要做的事定义一个接口，完成异步需要干的活:public interface ThreadDoSomethingObj {public ThreadExecuteResult DoSomething(Object input_obj);}2 异步执行完成后，执行结果的返回和执行数据的输出定义一个输出结果类，输出result和Serializable 的对象:public...
Android常见的异步线程框架
最新发布
liuhaikang的博客
04-13 1114
当涉及到在 Android 应用程序中处理耗时操作时，如网络请求、数据库访问、IO 操作等，使用异步线程框架是一种常见的方式。
Android框架|异步-Rxjava2.x(二)
LJY_Qt的博客
09-09 473
RxJava的简单使用 常见操作符
Github 上Top1的Android 异步网络请求框架
ZeroFlutter
06-03 3050
今天给大家分享一个github上Top1的Android异步网络请求框架的使用方法，我给大家分享一个它的基本用法。 先来一个简单的get请求 AsyncHttpClient client = new AsyncHttpClient(); client.get("http://www.google.com", new AsyncHttpResponseHandler() { @Override
android异步任务框架,详解Android App中的AsyncTask异步任务执行方式
weixin_36041020的博客
05-27 378
基本概念AsyncTask：异步任务，从字面上来说，就是在我们的UI主线程运行的时候，异步的完成一些操作。AsyncTask允许我们的执行一个异步的任务在后台。我们可以将耗时的操作放在异步任务当中来执行，并随时将任务执行的结果返回给我们的UI线程来更新我们的UI控件。通过AsyncTask我们可以轻松的解决多线程之间的通信问题。怎么来理解AsyncTask呢？通俗一点来说，AsyncTask就相当...
android异步请求框架,本篇文章我们来一起写一个最基本的Android异步网络请求框架，借此来了解下Android中网络请求的相关知识。由于个人水平有限，文中难免存在疏忽和谬误，希望...
weixin_35065221的博客
06-03 234
本篇文章我们来一起写一个最基本的Android异步网络请求框架，借此来了解下Android中网络请求的相关知识。由于个人水平有限，文中难免存在疏忽和谬误，希望大家可以指出，谢谢大家。1. 同步网络请求以HTTP的GET请求为例，我们来介绍一下Android中一个基本的同步请求框架的实现。直接贴代码：public class HttpUtils {public static byte[] get(S...
Android开发入门：从零开始构建应用
本书从入门级概念开始，逐步引导读者理解和掌握Android平台的基本知识和技术。它涵盖了开发环境的搭建，让初学者能够顺利地在自己的计算机上设置和配置必要的工具，如Android Studio，这是Android应用开发的主要集成...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值