Android异步任务AsyncTask

最新推荐文章于 2024-07-21 21:22:17 发布
最新推荐文章于 2024-07-21 21:22:17 发布
阅读量1.1k 收藏 3
点赞数
分类专栏： Android进阶 文章标签： android asynctask 异步
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenzheng8975/article/details/53893666
版权

一、概述
Android是单线程模型，耗时的操作必须放在非主线程中执行，对此，我们需要使用多线程/线程池或者AsyncTask等来完成异步加载任务。

二、AsyncTask
AsyncTask<Params, Progress, Result>是一个抽象类，通常用于被继承，继承AsyncTask需要指定如下三个泛型参数：
Params：启动任务时输入参数的类型
Progress：后台任务执行中返回进度值的类型
Result：后台执行任务完成后返回结果的类型

AsyncTask子类的回调方法：
doInBackground：必须重写，异步执行后台线程将要完成的任务
onPreExecute：执行后台耗时操作前被调用，通常用户完成一些初始化操作
onPostExecute：当doInBackground()完成后系统会自动调用该方法，并将doInBackground方法返回的值传给该方法
onProgressUpdate：在doInBackground()方法中调用publishProgress()方法更新任务的执行进度后，就会触发该方法。

注意事项：
必须在主线程中创建AsyncTask实例
execute方法必须在主线程中调用
重写的四个方法是系统自动调用的，不应手动调用

三、异步加载图片
1.效果图如下：
这里写图片描述
2.核心代码：

ImageAsyncTaskActivity.java

package com.czhappy.asynctaskdemo.activity;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.AsyncTask;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.ImageView;
import android.widget.ProgressBar;

import com.czhappy.asynctaskdemo.R;

import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;

/**
 * Description:图片加载演示
 * User: chenzheng
 * Date: 2016/12/23 0023
 * Time: 10:43
 */
public class ImageAsyncTaskActivity extends AppCompatActivity {

    private ImageView imageView;
    private ProgressBar progressBar;
    private static String imageUrl = "http://img.hb.aicdn.com/761f1bce319b745e663fed957606b4b5d167b9bff70a-nfBc9N_fw580";

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

        imageView = (ImageView) findViewById(R.id.imageView);
        progressBar = (ProgressBar) findViewById(R.id.progressBar);

        //开启异步线程操作
        new MyAsyncTask().execute(imageUrl);
    }

    class MyAsyncTask extends AsyncTask<String, Void, Bitmap>{

        /**
         * 初始化操作
         */
        @Override
        protected void onPreExecute() {
            super.onPreExecute();
            progressBar.setVisibility(View.VISIBLE);

        }

        @Override
        protected Bitmap doInBackground(String... params) {
            String url = params[0];//这里只有一个参数，直接获取
            Bitmap bitmap = null;
            URLConnection connection ;
            InputStream is;
            try {
                connection = new URL(url).openConnection();
                is = connection.getInputStream();
                BufferedInputStream bis = new BufferedInputStream(is);
                //休眠3秒防止加载太快，看不到加载效果
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                bitmap = BitmapFactory.decodeStream(bis);
                bis.close();
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return bitmap;
        }

        @Override
        protected void onPostExecute(Bitmap bitmap) {
            super.onPostExecute(bitmap);
            progressBar.setVisibility(View.GONE);
            if(bitmap!=null){
                imageView.setImageBitmap(bitmap);
            }
        }
    }
}

四、水平进度条异步加载演示
1.效果图：
这里写图片描述
2.核心代码：
ProgressBarTestActivity.java

package com.czhappy.asynctaskdemo.activity;

import android.os.AsyncTask;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.widget.ProgressBar;

import com.czhappy.asynctaskdemo.R;

/**
 * Description:水平进度条调用演示
 * User: chenzheng
 * Date: 2016/12/23 0023
 * Time: 11:38
 */
public class ProgressBarTestActivity extends AppCompatActivity {

    private ProgressBar progressBar;
    private MyAsyncTask mTask;

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

        progressBar = (ProgressBar) findViewById(R.id.progressBar);

        mTask = new MyAsyncTask();
        mTask.execute();
    }

    class MyAsyncTask extends AsyncTask<Void, Integer, Void>{

        @Override
        protected Void doInBackground(Void... params) {
            for (int i = 0; i < 100; i++) {
                //如果已经设置成cancel，则终止掉当前的进程
                if(mTask.isCancelled()){
                    break;

                }
                publishProgress(i);
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
            return null;
        }

        @Override
        protected void onProgressUpdate(Integer... values) {
            super.onProgressUpdate(values);
            if(mTask.isCancelled()){
                return;

            }
            progressBar.setProgress(values[0]);
        }
    }

    @Override
    protected void onPause() {
        super.onPause();
        if(mTask!=null && mTask.getStatus()== AsyncTask.Status.RUNNING){

            //cancel方法只是将对应的AsyncTask状态标记为cancel，并没有真正的取消掉
            mTask.cancel(true);
        }
    }
}

六、高效ListView及图片一级缓存
本例使用的是Android提供LruCache类实现一级缓存，而对于高效ListView这块我们是判断ListView滑动状态，决定何时加载图片以提高效率：
ListView滑动停止后才加载可见项
ListView滑动时，取消所有加载项
1.效果图
这里写图片描述
核心代码：
News.java

package com.czhappy.asynctaskdemo.model;

/**
 * Description:
 * User: chenzheng
 * Date: 2016/12/24 0024
 * Time: 11:23
 */
public class News {

    public String newsIconUrl;
    public String newsTitle;
    public String newsContent;
}

NewsListActivity.java

package com.czhappy.asynctaskdemo.activity;

import android.os.AsyncTask;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.widget.ListView;

import com.czhappy.asynctaskdemo.R;
import com.czhappy.asynctaskdemo.adapter.NewsListAdapter;
import com.czhappy.asynctaskdemo.model.News;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;

/**
 * Description:
 * User: chenzheng
 * Date: 2016/12/24 0024
 * Time: 11:18
 */
public class NewsListActivity extends AppCompatActivity {

    private ListView mListView;
    private String mUrl = "http://www.imooc.com/api/teacher?type=4&num=30";

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

        mListView = (ListView) findViewById(R.id.listView);
        new NewsAsyncTask().execute(mUrl);

    }

    /**
     * 实现网络的异步访问
     */
    class NewsAsyncTask extends AsyncTask<String, Void, List<News>>{

        @Override
        protected List<News> doInBackground(String... params) {
            return getJsonData(params[0]);
        }

        @Override
        protected void onPostExecute(List<News> list) {
            super.onPostExecute(list);
            NewsListAdapter adapter = new NewsListAdapter(NewsListActivity.this, list, mListView);
            mListView.setAdapter(adapter);
        }
    }

    private List<News> getJsonData(String url) {
        List<News> list = new ArrayList<>();
        try {
            String jsonString = readStream(new URL(url).openStream());
            Log.e("tag", "jsonString:"+jsonString);
            JSONObject jsonObject;
            News news;
            try {
                jsonObject = new JSONObject(jsonString);
                JSONArray jsonArray = jsonObject.getJSONArray("data");
                for (int i = 0; i < jsonArray.length(); i++) {
                    jsonObject = jsonArray.getJSONObject(i);
                    news = new News();
                    news.newsIconUrl = jsonObject.getString("picSmall");
                    news.newsTitle = jsonObject.getString("name");
                    news.newsContent = jsonObject.getString("description");
                    list.add(news);

                }
            } catch (JSONException e) {
                e.printStackTrace();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        return list;
    }

    private String readStream(InputStream is){
        InputStreamReader isr;
        String result = "";
        try {
            String line = "";
            isr = new InputStreamReader(is, "utf-8");//字节流转化为字符流
            BufferedReader br = new BufferedReader(isr);
            while((line = br.readLine())!=null){
                result += line;
            }

        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return result;

    }
}

NewsListAdapter.java

package com.czhappy.asynctaskdemo.adapter;

import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AbsListView;
import android.widget.BaseAdapter;
import android.widget.ImageView;
import android.widget.ListView;
import android.widget.TextView;

import com.czhappy.asynctaskdemo.R;
import com.czhappy.asynctaskdemo.model.News;
import com.czhappy.asynctaskdemo.utils.ImageLoader;

import java.util.List;

/**
 * Description:
 * User: chenzheng
 * Date: 2016/12/24 0024
 * Time: 13:53
 */
public class NewsListAdapter extends BaseAdapter implements AbsListView.OnScrollListener{

    private Context context;
    private List<News> list;
    private LayoutInflater mInflater;

    private ImageLoader mImageLoader;

    private int mStart, mEnd;
    public static String [] URLS;

    private boolean mFirstIn;

    public NewsListAdapter(Context context, List<News> list, ListView listView) {
        this.context = context;
        this.list = list;
        mInflater = LayoutInflater.from(context);
        mImageLoader = new ImageLoader(listView);
        URLS = new String[list.size()];
        for (int i = 0; i < list.size(); i++) {
            URLS[i] = list.get(i).newsIconUrl;        }
        listView.setOnScrollListener(this);//绑定监听事件
        mFirstIn = true;
    }

    @Override
    public int getCount() {
        return list.size();
    }

    @Override
    public Object getItem(int position) {
        return list.get(position);
    }

    @Override
    public long getItemId(int position) {
        return position;
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        ViewHolder viewHolder=null;
        if(convertView==null){
            viewHolder = new ViewHolder();
            convertView = mInflater.inflate(R.layout.news_list_item, null);
            viewHolder.image_iv = (ImageView) convertView.findViewById(R.id.image_iv);
            viewHolder.title_tv = (TextView) convertView.findViewById(R.id.title_tv);
            viewHolder.content_tv = (TextView) convertView.findViewById(R.id.content_tv);
            convertView.setTag(viewHolder);
        }else{
            viewHolder = (ViewHolder) convertView.getTag();
        }

        //viewHolder.image_iv.setImageResource(R.mipmap.ic_launcher);
        String url = list.get(position).newsIconUrl;
        viewHolder.image_iv.setTag(url);//设置tag，防止图片错乱
        //mImageLoader.showImageByThread(viewHolder.image_iv, url);
        mImageLoader.showImageByAsyncTask(viewHolder.image_iv, url);
        viewHolder.title_tv.setText(list.get(position).newsTitle);
        viewHolder.content_tv.setText(list.get(position).newsContent);

        return convertView;
    }

    @Override
    public void onScrollStateChanged(AbsListView view, int scrollState) {
        if(scrollState == SCROLL_STATE_IDLE){//滑动停止状态，加载可见项
            mImageLoader.loadImage(mStart, mEnd);
        }else{//停止加载可见项
            mImageLoader.cancelAllTasks();
        }
    }

    @Override
    public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
        mStart = firstVisibleItem;
        mEnd = firstVisibleItem + visibleItemCount;
        //第一次显示的时候调用
        if(mFirstIn && totalItemCount>0){
            mFirstIn = false;
            mImageLoader.loadImage(mStart, mEnd);
        }

    }

    class ViewHolder{
        TextView title_tv, content_tv;
        ImageView image_iv;

    }
}

ImageLoader.java

package com.czhappy.asynctaskdemo.utils;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.AsyncTask;
import android.os.Handler;
import android.os.Message;
import android.util.LruCache;
import android.widget.ImageView;
import android.widget.ListView;

import com.czhappy.asynctaskdemo.R;
import com.czhappy.asynctaskdemo.adapter.NewsListAdapter;

import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashSet;
import java.util.Set;

/**
 * Description:
 * User: chenzheng
 * Date: 2016/12/24 0024
 * Time: 14:08
 */
public class ImageLoader {

    private ImageView mImageView;
    private String mUrl;

    private LruCache<String, Bitmap> mCaches;//一级缓存保存在内存中
    private ListView mListView;
    private Set<NewsAsyncTask> mTasks;

    public ImageLoader(ListView listView){
        this.mListView = listView;
        mTasks = new HashSet<>();
        //获取最大可用内存
        int maxMemory = (int) Runtime.getRuntime().maxMemory();
        int cacheSize = maxMemory/4;//设置实际缓存大小
        mCaches = new LruCache<String, Bitmap>(cacheSize){
            /**
             * 在每次存入缓存的时候调用
             * @param key
             * @param value
             * @return
             */
            @Override
            protected int sizeOf(String key, Bitmap value) {
                return value.getByteCount();
            }
        };

    }

    /**
     * 增加到缓存
     * @param url
     * @param bitmap
     */
    public void addBitmapToCache(String url, Bitmap bitmap){

        if(getBitmapFromCache(url)==null){

            mCaches.put(url, bitmap);
        }
    }

    /**
     * 从缓存中获取数据
     * @param url
     * @return
     */
    public Bitmap getBitmapFromCache(String url){

        return mCaches.get(url);
    }

    private Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            if(mImageView.getTag().equals(mUrl)){
                mImageView.setImageBitmap((Bitmap) msg.obj);
            }

        }
    };

    public void showImageByThread(ImageView imageView, final String imageUrl){
        mImageView = imageView;
        mUrl = imageUrl;
        new Thread(){
            @Override
            public void run() {
                super.run();
                Bitmap bmp = getBitmapFromUrl(imageUrl);
                Message message = Message.obtain();//使用现有的Messsage，提高Message的效率
                message.obj = bmp;
                handler.sendMessage(message);

            }
        }.start();

    }

    /**
     * 从网络下载图片
     * @param iurl
     * @return
     */
    public Bitmap getBitmapFromUrl(String iurl){

        Bitmap bitmap = null;
        InputStream is = null;
        try {
            URL url = new URL(iurl);
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            is = new BufferedInputStream(connection.getInputStream());
            bitmap = BitmapFactory.decodeStream(is);
            connection.disconnect();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return bitmap;
    }

    public void showImageByAsyncTask(ImageView imageView, final String imageUrl){
        //从缓存中获取图片，判断是否存在
        Bitmap bitmap = getBitmapFromCache(imageUrl);
        if(bitmap==null){
            //从网络下载图片
            imageView.setImageResource(R.mipmap.ic_launcher);
            //new NewsAsyncTask(imageView, imageUrl).execute(imageUrl);
        }else{
            //如果缓存中存在，则直接显示图片
            imageView.setImageBitmap(bitmap);
        }


    }

    private class NewsAsyncTask extends AsyncTask<String, Void, Bitmap>{

        //private ImageView mImageView;
        private String mUrl;

        public NewsAsyncTask(String url) {
            //this.mImageView = mImageView;
            this.mUrl = url;
        }

        @Override
        protected Bitmap doInBackground(String... params) {
            //从网络获取图片
            Bitmap bitmap = getBitmapFromUrl(params[0]);
            if(bitmap!=null){
                //将Bitmap保存到缓存
                addBitmapToCache(params[0], bitmap);
            }
            return bitmap;
        }

        @Override
        protected void onPostExecute(Bitmap bitmap) {
            super.onPostExecute(bitmap);
            ImageView imageView = (ImageView) mListView.findViewWithTag(mUrl);
            if(imageView!=null && bitmap!=null){
                imageView.setImageBitmap(bitmap);
            }
            mTasks.remove(this);
        }
    }

    /**
     * 用来加载从start到end的数据
     * @param start
     * @param end
     */
    public void loadImage(int start, int end){

        for (int i = start; i < end; i++) {
            String url = NewsListAdapter.URLS[i];
            //从缓存中获取图片，判断是否存在
            Bitmap bitmap = getBitmapFromCache(url);
            if(bitmap==null){
                //从网络下载图片
                NewsAsyncTask task = new NewsAsyncTask(url);
                task.execute(url);
                mTasks.add(task);
            }else{
                //如果缓存中存在，则直接显示图片
                ImageView imageView = (ImageView) mListView.findViewWithTag(url);
                imageView.setImageBitmap(bitmap);
            }
        }

    }

    public void cancelAllTasks(){
        if(mTasks!=null){
            for (NewsAsyncTask task : mTasks){
                task.cancel(true);
            }

        }

    }
}

七、源码下载

http://download.csdn.net/detail/chenzheng8975/9722102

风云正
关注
专栏目录
Android 异步任务
qq_30960163的博客
08-23 501
1.异步任务（AsyncTask）简介 Android异步任务(AsyncTask)是一个抽象类，通常用于被继承，继承AsyncTask时需要指定如下三个泛型参数。 1.1）Params：启动任务执行的输入参数。比如HTTP请求的URL。 1.2）Process：后台任务完成的进度值的。比如进度条的百分比。 1.3）Resul
android异步任务
11-19
android异步任务
Android同步异步任务与多线程和Handler消息处理机制
扬帆起航
07-18 988
Android同步异步任务与多线程和Handler消息处理机制
Android异步任务
修远的专栏
06-03 815
本文主要探讨Android平台提供的各种异步加载机制，包括它们的适用场景、使用方法等。1. AsynTaskAsynTask适用于最长可以持续几秒钟的短时间的操作，对于长时间的操作，建议使用java.util.concurrent包下的多线程框架。定义一个AsynTask时需要提供以下三个泛型参数的实际类型: Params：被传递给后台线程执行的参数的类型 Progress：后台线程执
Android中的异步任务
zwyAndroid的博客
05-19 343
异步任务对象：（AsyncTask）抽象类 此对象属于工具类； 目的：简化消息模型编写 方法：一部分在主线程运行，一部分在工作线程运行 用法：构建一个子类对象，继承AsyncTask，重写父类方法 线程池： 父类接口：Executor 子接口：ExecutorService、ScheduledExecutorService（不常用） 实现类：ThreadPoolExecutor
android中的异步任务
huangbaokang的博客
01-04 435
前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到教程 还是以下载并安装最新APK例子 package com.hbk.layoutdemo; import java.io.File; import java.io.FileOutputStream; import java.io.InputStream; import java.net.HttpURLConnection; import java.net.URL; import android.app.Act
Android 异步任务AsyncTask
10-28
下面将详细阐述Android异步任务AsyncTask的使用、原理以及如何利用它发送POST请求并获取JSON字符串。 AsyncTask的工作流程主要包括三个步骤：onPreExecute()、doInBackground()和onPostExecute()。首先，当调用...
Android异步任务AsyncTask实例源码
12-27
Android是单线程模型，耗时的操作必须放在非主线程中执行，对此，我们需要使用多线程/线程池或者AsyncTask等来完成异步加载任务。 博客地址：http://blog.csdn.net/chenzheng8975/article/details/53893666
Android异步任务AsyncTask的简单DEMO
09-22
在实际项目中，除了AsyncTask，还可以考虑使用Handler、Runnable、IntentService、Loader或第三方库（如RxJava、LiveData等）来实现异步任务。选择哪种方式取决于具体需求，如任务的复杂性、是否需要持续运行、与UI...
Android最全最简单的异步任务AsyncTask使用解析
04-27
Android异步任务AsyncTask使用解析 Android异步任务AsyncTask使用解析是指在Android应用程序中使用AsyncTask来实现异步任务的处理。AsyncTask是一个抽象类，使用时需要继承这个类，然后调用execute()方法。...
Android异步任务AsyncTask原理（基于Android9.0）
04-15 1161
AsyncTask原理前言AsyncTask介绍源码分析 前言 在Android开发中经常会通过线程去执行耗时的任务，并且在任务执行完之后通常会用到Handler来更新UI。虽然实现简单，但是有多个任务同时执行时则会显得代码很臃肿。Android提供了AsyncTask，它使得异步任务实现起来更加简单，代码更简洁。 AsyncTask介绍 AsyncTask是一个抽象的泛型类，它有3个泛型参数，分...
Android 异步任务和Google的异步任务
03-08
Android 异步任务。减少了许多重复的工作，是一个Google的AsyncTask的精简版（使用Google的AsyncTask，内部开销比较大，不适合简单开发，对于比较负责或者要求多线程异步任务的时候比较适合使用Google的AsyncTask）
android异步任务,Android 异步任务(AsyncTask)
weixin_32820311的博客
05-27 131
packagecom.lucky.test36asynctask;importandroid.annotation.SuppressLint;importandroid.app.ProgressDialog;importandroid.content.Context;importandroid.os.AsyncTask;importandroid.support.v7.app.AppCompatA...
闲聊 Android 异步任务
龙衣
04-29 1261
在 Android 中有主线程和子线程，主线程只有一个，子线程可以有多个，当有多个子线程时就是多线程了。多线程属于异步处理任务技术，该技术主要是为了提高应用效率问题。 线程？ 线程是程序执行的最小单元。 多线程？ 多线程就是多个线程一起执行。 例如：我们使用微信聊天的同时还能继续播放着公众号文章中的音频。 多进程？ 进程是程序的基本执行实体。我们手机上的每个 App 都是一个进程。 在 And...
安卓的异步任务AsyncTask
weixin_71792169的博客
10-16 633
第二个泛型用来限制onProgressUpdate(Progress)和publishProgress(Progress）方法传入参数的类型,在publishProgress方法中传入的参数会在onProgressUpdate回调方法中被使用。第一个泛型用来限制execute(Params)和doInBackground(Params)方法传入参数的类型，在execute方法中传入的参数会在doInBackground回调方法中被使用。广泛地讲异步任务就是以多线程的方式完成的功能需求，相对于同步。
Android必学之AsyncTask
dehuai19940321的博客
12-09 246
AsyncTask,即异步任务,是Android给我们提供的一个处理异步任务的类.通过此类,可以实现UI线程和后台线程进行通讯,后台线程执行异步任务,并把结果返回给UI线程. .为什么需要使用异步任务? 我们知道,Android中只有UI线程,也就是主线程才能进行对UI的更新操作,而其他线程是不能直接操作UI的.这样的好处是保证了UI的稳定性和准确性,避免多个线程同时对UI进行操作而...
安卓的异步任务
qq_37019196的博客
08-23 192
1.为什么要用异步任务？ 首先安卓里面的线程分为UI线程和子线程，但是在主线程里面不能进行耗时操作，所有的耗时操作需要放到子线程里面去进行。 而AsyncTask的作用就是实现异步任务，解决耗时操作的。 2.ANR是什么？ ANR即application not response，在UI线程里面进行耗时操作就会出现ANR 3.那些属于耗时操作？ 耗时的网络访问 在主线程中解析网络返回的数据 在主线...
Android的异步任务实现
最新发布
weixin_58719774的博客
07-21 2321
在Android应用开发中，异步任务处理是确保应用响应性和性能的关键。随着用户对流畅体验的期望不断提高，传统的同步执行方式已经无法满足需求。异步执行允许应用在后台处理耗时操作，同时保持前台界面的流畅和响应。在早期的Android开发中，异步任务通常通过手动创建线程或使用Thread和Handler来实现。这种方式虽然有效，但代码复杂且容易出错。随着AsyncTask的引入，开发者获得了一种更简单的异步任务处理方式。AsyncTask允许在后台线程中执行耗时操作，并在操作完成后将结果回调到主线程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值