android 使用asynctask结合fragment更新UI（另附线程池管理示例）

最新推荐文章于 2024-08-15 15:26:49 发布

mmsx

最新推荐文章于 2024-08-15 15:26:49 发布

阅读量3.6k

点赞数 4

分类专栏： Android 移动开发 Android 常用开发技术文章标签： asynctask ui 线程池管理设计

本文链接：https://blog.csdn.net/qq_16064871/article/details/70767949

版权

Android 常用开发技术同时被 2 个专栏收录

79 篇文章 11 订阅

订阅专栏

Android 移动开发

65 篇文章 4 订阅

订阅专栏

使用asynctask结合fragment更新UI。在android上有不少设计都是使用fragment，因为使用fragment的生命周期可以和activity一起管理，再受到横竖屏旋转也可以保持稳定。使用asynctask，大家都很熟悉，这个有一个更新进度方法啦。就是巧妙使用这个方法。然后还能耗时工作放在这里。我写的这个可以作为定时器使用。更新的时间可以自已设置。

demo下载：http://download.csdn.net/detail/qq_16064871/9824371

1，效果图

2，主要代码

    public class LoopAsynTaskUpdate extends AsyncTask<Long, Long, Boolean> {
        // 需要循环执行的次数
        private WeakReference<onAsynTaskUpdateListener> mOnListener;
        private long mStartMillTime = 0;

        public void setAsynTaskUpdateListener(onAsynTaskUpdateListener listener) {
            mOnListener = null;
            mOnListener = new WeakReference<>(listener);
        }

        @Override
        protected Boolean doInBackground(Long... arg0) {
            synchronized (CusomAsyncTaskFragment.class) {
                long nCurrentLoopIndex = 0;
                while (mAsynBackSmoothRunning) {
                    if (mStartMillTime == 0) mStartMillTime = SystemClock.elapsedRealtime();
                    long havePassTime = SystemClock.elapsedRealtime() - mStartMillTime;
                    if (havePassTime < nCurrentLoopIndex * arg0[0]) {
                        try {
                            Thread.sleep(nCurrentLoopIndex * arg0[0] - havePassTime);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    nCurrentLoopIndex++;
                    if (mOnListener.get() == null) continue;
                    // 通知界面当前进行的状态
                    publishProgress(nCurrentLoopIndex);
                }
                return true;
            }
        }

        @Override
        protected void onProgressUpdate(Long... values) {
            //更新进度条的回调，改成刷新界面
            if (mOnListener.get() != null) mOnListener.get().asynTaskUpdateCallBack(true);
        }

        @Override
        protected void onPostExecute(Boolean b) {
            //  通知UI, 并直接返回不再循环
            if (mOnListener.get() == null) return;
        }
    }

extends AsyncTask<Long, Long, Boolean> 和 doInBackground(Long... arg0)以及onProgressUpdate(Long... values) 里面参数都是对应的。我这里使用Long类型，因为

传入是1000L(1秒)。就是毫秒啦，这样更加灵活。

WeakReference<onAsynTaskUpdateListener> mOnListener; 这个回调的监听，使用弱引用，可以保证线程或者对象安全。

synchronized 里面使用这个关键字，就是为了保持一个更新状态。

与Fragment结合的完整代码如下：

package com.asynctask.sample.task;

import android.app.Fragment;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.SystemClock;

import java.lang.ref.WeakReference;
import java.util.concurrent.Executors;

/**
 * 依赖于Fragment的生命周期
 */
public class CusomAsyncTaskFragment extends Fragment {
    // 后台任务是否继续执行
    private boolean mAsynBackSmoothRunning = false;
    // 后台任务实例
    private LoopAsynTaskUpdate mLoopAsynTaskUpdate;

    public void runTask(onAsynTaskUpdateListener listener, Long millisecond) {

        // 任务继续运行, 但是已经申请结束
        if (mLoopAsynTaskUpdate != null && !mAsynBackSmoothRunning)
            mLoopAsynTaskUpdate = null;

        // 任务正在运行,不处理,直接退出
        if (mLoopAsynTaskUpdate != null && mAsynBackSmoothRunning) {
            mLoopAsynTaskUpdate.setAsynTaskUpdateListener(listener);
            return;
        }

        // 开启任务
        mLoopAsynTaskUpdate = new LoopAsynTaskUpdate();
        mLoopAsynTaskUpdate.setAsynTaskUpdateListener(listener);
        mAsynBackSmoothRunning = true;
        mLoopAsynTaskUpdate.executeOnExecutor(Executors.newFixedThreadPool(3), millisecond);
    }

    public void updateListener(onAsynTaskUpdateListener listener) {
        if (mLoopAsynTaskUpdate != null) mLoopAsynTaskUpdate.setAsynTaskUpdateListener(listener);
    }

    public void stopTask() {
        mAsynBackSmoothRunning = false;
        mLoopAsynTaskUpdate = null;
    }

    public boolean getTaskStatus() {
        return mAsynBackSmoothRunning;
    }

    @Override
    public void onCreate(Bundle saveInstanceState) {
        super.onCreate(saveInstanceState);
        setRetainInstance(true);
    }

    @Override
    public void onDestroy() {
        stopTask();
        super.onDestroy();
    }

    //接口回调
    public interface onAsynTaskUpdateListener {
        public abstract void asynTaskUpdateCallBack(Boolean update);
    }

    public class LoopAsynTaskUpdate extends AsyncTask<Long, Long, Boolean> {
        // 需要循环执行的次数
        private WeakReference<onAsynTaskUpdateListener> mOnListener;
        private long mStartMillTime = 0;

        public void setAsynTaskUpdateListener(onAsynTaskUpdateListener listener) {
            mOnListener = null;
            mOnListener = new WeakReference<>(listener);
        }

        @Override
        protected Boolean doInBackground(Long... arg0) {
            synchronized (CusomAsyncTaskFragment.class) {
                long nCurrentLoopIndex = 0;
                while (mAsynBackSmoothRunning) {
                    if (mStartMillTime == 0) mStartMillTime = SystemClock.elapsedRealtime();
                    long havePassTime = SystemClock.elapsedRealtime() - mStartMillTime;
                    if (havePassTime < nCurrentLoopIndex * arg0[0]) {
                        try {
                            Thread.sleep(nCurrentLoopIndex * arg0[0] - havePassTime);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    nCurrentLoopIndex++;
                    if (mOnListener.get() == null) continue;
                    // 通知界面当前进行的状态
                    publishProgress(nCurrentLoopIndex);
                }
                return true;
            }
        }

        @Override
        protected void onProgressUpdate(Long... values) {
            //更新进度条的回调，改成刷新界面
            if (mOnListener.get() != null) mOnListener.get().asynTaskUpdateCallBack(true);
        }

        @Override
        protected void onPostExecute(Boolean b) {
            //  通知UI, 并直接返回不再循环
            if (mOnListener.get() == null) return;
        }
    }
}

用Fragment生命周期来管理AsyncTask。确实是个不错选择。

rxpermissions是针对6.0以上权限管理的库，思想就是基于Fragment来设计的。因为Fragment不用界面也是可以的。就可以做很多事情。

github网址：https://github.com/tbruyelle/RxPermissions

3，activity调用

package com.asynctask.sample;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.TextView;

import com.asynctask.sample.task.CusomAsyncTaskFragment;

public class AsynTaskUpdateUIActivity extends AppCompatActivity implements View.OnClickListener
        ,CusomAsyncTaskFragment.onAsynTaskUpdateListener {
    private CusomAsyncTaskFragment mCusomAsyncTaskFragment = null;
    private TextView mTvShow;
    private int nIndex = 0;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_asyntask_update);
        initView();
    }

    private void initView() {
        findViewById(R.id.button).setOnClickListener(this);
        findViewById(R.id.button1).setOnClickListener(this);
        mTvShow = (TextView)findViewById(R.id.textView);

        mCusomAsyncTaskFragment = (CusomAsyncTaskFragment)(getFragmentManager()).findFragmentByTag("AsyncTaskFragment");
        if (mCusomAsyncTaskFragment == null) {
            mCusomAsyncTaskFragment = new CusomAsyncTaskFragment();
            getFragmentManager().beginTransaction().add(mCusomAsyncTaskFragment, "AsyncTaskFragment").commit();
        }
        if (mCusomAsyncTaskFragment.getTaskStatus())
            mCusomAsyncTaskFragment.updateListener(this);
    }

    @Override
    public void asynTaskUpdateCallBack(Boolean update) {
        nIndex ++;
        if(mTvShow != null)
            mTvShow.setText("" +  nIndex);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.button:
                mCusomAsyncTaskFragment.runTask(this,50L);
                break;
            case R.id.button1:
//                startActivity(new Intent(this,DirectGridActivity.class));
                break;
        }
    }
}

4，网上找到一个线程池管理类

也可以借鉴一下，用在什么需求上也是可以的。

package com.asynctask.sample.task;

import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 下载线程池管理
 */
public class ThreadPoolManager {
    /**
     * 单例设计模式（饿汉式）
     *  单例首先私有化构造方法，然后饿汉式一开始就开始创建，并提供get方法
     */
    private static ThreadPoolManager mInstance = new ThreadPoolManager();
    public static ThreadPoolManager getInstance() {
        return mInstance;
    }

    private int corePoolSize;//核心线程池的数量，同时能够执行的线程数量
    private int maximumPoolSize;//最大线程池数量，表示当缓冲队列满的时候能继续容纳的等待任务的数量
    private long keepAliveTime = 1;//存活时间
    private TimeUnit unit = TimeUnit.HOURS;
    private ThreadPoolExecutor executor;
    private ThreadPoolManager() {
        /**
         * 给corePoolSize赋值：当前设备可用处理器核心数*2 + 1,能够让cpu的效率得到最大程度执行（有研究论证的）
         */
        corePoolSize = Runtime.getRuntime().availableProcessors()*2+1;
        maximumPoolSize = corePoolSize; //虽然maximumPoolSize用不到，但是需要赋值，否则报错
        executor = new ThreadPoolExecutor(
                corePoolSize, //当某个核心任务执行完毕，会依次从缓冲队列中取出等待任务
                maximumPoolSize, //5,先corePoolSize,然后new LinkedBlockingQueue<Runnable>(),然后maximumPoolSize,但是它的数量是包含了corePoolSize的
                keepAliveTime, //表示的是maximumPoolSize当中等待任务的存活时间
                unit,
                new LinkedBlockingQueue<Runnable>(), //缓冲队列，用于存放等待任务，Linked的先进先出
                Executors.defaultThreadFactory(), //创建线程的工厂
                new ThreadPoolExecutor.AbortPolicy() //用来对超出maximumPoolSize的任务的处理策略
        );
    }
    /**
     * 执行任务
     */
    public void execute(Runnable runnable){
        if(runnable==null)return;

        executor.execute(runnable);
    }
    /**
     * 从线程池中移除任务
     */
    public void remove(Runnable runnable){
        if(runnable==null)return;

        executor.remove(runnable);
    }
}

简单测试调用

package com.asynctask.sample;

import android.os.Bundle;
import android.os.SystemClock;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.TextView;

import com.asynctask.sample.task.ThreadPoolManager;

public class ThreadPoolTestActivity extends AppCompatActivity implements View.OnClickListener {
    private TextView mTvShow;
    private int nIndex = 0;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_asyntask_update);
        initView();
        /**
         * 创建九个任务
         */
        for (int i = 0; i < 9; i++) {
            ThreadPoolManager.getInstance().execute(new DownloadTask(i));
        }
    }
    /**
     * 模仿下载任务，实现Runnable
     */
    class DownloadTask implements Runnable{
        private int num;
        public DownloadTask(int num) {
            super();
            this.num = num;
            Log.e("JAVA", "task - "+num + " 等待中...");
        }
        @Override
        public void run() {
            Log.e("JAVA", "task - "+num + " 开始执行了...开始执行了...");
            SystemClock.sleep(5000); //模拟延时执行的时间
            Log.e("JAVA", "task - "+num + " 结束了...");
        }
    }

    private void initView() {
        findViewById(R.id.button).setOnClickListener(this);
        findViewById(R.id.button1).setOnClickListener(this);
        mTvShow = (TextView)findViewById(R.id.textView);
        mTvShow.setText("看log打印，界面没什么用");
    }


    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.button:
                break;
            case R.id.button1:
                break;
        }
    }
}

这个线程池代码也有一并打包：

demo下载：http://download.csdn.net/detail/qq_16064871/9824371