首页 > 编程开发 > Android

详细讲解AsyncTask使用说明(值得收藏)

来自：网络
时间：2024-06-09
阅读：

概念

AsyncTask：异步任务，从字面上来说，就是在我们的UI主线程运行的时候，异步的完成一些操作。AsyncTask允许我们的执行一个异步的任务在后台。我们可以将耗时的操作放在异步任务当中来执行，并随时将任务执行的结果返回给我们的UI线程来更新我们的UI控件。通过AsyncTask我们可以轻松的解决多线程之间的通信问题。

怎么来理解AsyncTask呢？通俗一点来说，AsyncTask就相当于Android给我们提供了一个多线程编程的一个框架，其介于Thread和Handler之间，我们如果要定义一个AsyncTask，就需要定义一个类来继承AsyncTask这个抽象类，并实现其唯一的一doInBackgroud 抽象方法。

类简介

AsyncTask　= handler + 两个线程池的维护一个任务队列线程池，一个执行线程池

其中：线程池用于线程调度、复用 & 执行任务；Handler用于异步通信

我们来看看AsyncTask这个抽象类的定义，当我们定义一个类来继承AsyncTask这个类的时候，我们需要为其指定3个泛型参数：

AsyncTask　<Params, Progress, Result>

  • Params: 这个泛型指定的是我们传递给异步任务执行时的参数的类型
  • Progress: 这个泛型指定的是我们的异步任务在执行的时候将执行的进度返回给UI线程的参数的类型
  • Result: 这个泛型指定的异步任务执行完后返回给UI线程的结果的类型

简单例子

private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> { 
                          //忽略
}
 public void onClick(View v) {
        try {
            URL url = new URL("http://blog.csdn.net/");
            new DownloadFilesTask().execute(url);
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }
    }

执行流程

一、在执行完 AsyncTask.excute() 后

详细讲解AsyncTask使用说明(值得收藏)

二、方法分析

常用的AsyncTask继承的方法有

  • onPreExecute()：异步任务开启之前回调，在主线程中执行
  • doInBackground()：执行异步任务，在线程池中执行
  • onProgressUpdate()：当doInBackground中调用publishProgress时回调，在主线程中执行
  • onPostExecute()：在异步任务执行之后回调，在主线程中执行
  • onCancelled()：在异步任务被取消时回调

小demo

效果图：

详细讲解AsyncTask使用说明(值得收藏)

Activity

public class AsyThreadActivity extends Activity implements View.OnClickListener {
    @BindView(R.id.btn_click)
    Button btnClick;
    @BindView(R.id.progress)
    ProgressBar progress;
    @BindView(R.id.btn_chancel)
    Button btnChancel;
    @BindView(R.id.text)
    TextView text;
    Mythread myasythread = new Mythread();
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_asythread);
        ButterKnife.bind(this);
        initClcik();
    }
    private void initClcik() {
        btnClick.setOnClickListener(this);
        btnChancel.setOnClickListener(this);
        myasythread.setOntextchance(new Mythread.Ontextchance() {
            @Override
            public void textchance(String s) {
                text.setText(s);
            }
            @Override
            public void progresschance(Integer number) {
                progress.setProgress(number);
            }
        });
    }
    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.btn_click:
                myasythread.execute();
                break;
            case R.id.btn_chancel:
                myasythread.cancel(true);
                break;
            default:
                break;
        }
    }
}

myAsyncTAsk

public class Mythread extends AsyncTask<String,Integer,String> {
    private Ontextchance ontextchance;
    public Mythread() {
        super();
    }
    @Override
    protected String doInBackground(String... params) {
        int count = 0;
        while(count<99){
            count = count + 1;
            publishProgress(count);
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
    @Override
    protected void onPreExecute() {
        ontextchance.textchance("加载中");
        super.onPreExecute();
    }
    @Override
    protected void onPostExecute(String s) {
        ontextchance.textchance("加载完毕");
        super.onPostExecute(s);
    }
    @Override
    protected void onProgressUpdate(Integer... values) {
        ontextchance.progresschance(values[0]);
        ontextchance.textchance("loading..." + values[0] + "%");
        super.onProgressUpdate(values);
    }
    @Override
    protected void onCancelled() {
        ontextchance.textchance("已取消");
        ontextchance.progresschance(0);
        super.onCancelled();
    }

源码分析

好吧 ，在想写之前刚刚好瞄到一位小哥哥的文章写得超级好，然后我就偷懒一把，如下。

源码分析是基于API24的源码，我将会按照下面AsyncTask运行的过程来分析

一、主分支

首先，execute()方法，开启异步任务
接着，onPreExecute()方法，异步任务开启前
接着，doInBackground()方法，异步任务正在执行
最后，onPostExecute()方法，异步任务完成

二、次分支

onProgressUpdate()方法，异步任务更新UI
onCancelled()方法，异步任务取消

主分支部分

代码开始的地方，是在创建AsyncTask类之后执行的execute()方法

public final AsyncTask<Params, Progress, Result> execute(Params... params) {
    return executeOnExecutor(sDefaultExecutor, params);
}

execute()方法会调用executeOnExecutor()方法

public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
            Params... params) {
    if (mStatus != Status.PENDING) {
        switch (mStatus) {
            case RUNNING:
                throw new IllegalStateException("Cannot execute task:"
                        + " the task is already running.");
            case FINISHED:
                throw new IllegalStateException("Cannot execute task:"
                        + " the task has already been executed "
                        + "(a task can be executed only once)");
        }
    }
    mStatus = Status.RUNNING;
    onPreExecute();
    mWorker.mParams = params;
    exec.execute(mFuture);
    return this;
}

AsyncTask定义了一个mStatus变量，表示异步任务的运行状态，分别是PENDING、RUNNING、FINISHED，当只有PENDING状态时，AsyncTask才会执行，这样也就保证了AsyncTask只会被执行一次

继续往下执行，mStatus会被标记为RUNNING，接着执行，onPreExecute()，将参数赋值给mWorker，然后还有execute(mFuture)

这里的mWorker和mFuture究竟是什么，我们往下追踪，来到AsyncTask的构造函数中，可以找到这两个的初始化

public AsyncTask() {
    mWorker = new WorkerRunnable<Params, Result>() {
        public Result call() throws Exception {
            mTaskInvoked.set(true);
            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
            //noinspection unchecked
            Result result = doInBackground(mParams);
            Binder.flushPendingCommands();
            return postResult(result);
        }
    };
    mFuture = new FutureTask<Result>(mWorker) {
        @Override
        protected void done() {
            try {
                postResultIfNotInvoked(get());
            } catch (InterruptedException e) {
                android.util.Log.w(LOG_TAG, e);
            } catch (ExecutionException e) {
                throw new RuntimeException("An error occurred while executing doInBackground()",
                        e.getCause());
            } catch (CancellationException e) {
                postResultIfNotInvoked(null);
            }
        }
    };
}

一、分析mWorker

mWorker是一个WorkerRunnable对象，跟踪WorkerRunnable

private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
    Params[] mParams;
}

实际上，WorkerRunnable是AsyncTask的一个抽象内部类，实现了Callable接口

二、分析mFuture

mFuture是一个FutureTask对象，跟踪FutureTask

public FutureTask(Callable<V> callable) {
    if (callable == null)
        throw new NullPointerException();
    this.callable = callable;
    this.state = NEW;       // ensure visibility of callable
}

实际上，FutureTask是java.util.concurrent包下的一个类，参数是个callable，并且将它赋值给FutureTask类中的callable

三、回过头来看

回到我们AsyncTask初始化mFuture，这里的参数是mWorker也就不奇怪了，因为mWorker就是一个callable，我们在上面赋值给FutureTask类中的callable就是这个mWorker

mFuture = new FutureTask<Result>(mWorker)

而关于mWorker和mFuture的初始化早在我们Activity中初始化好了，因为构造函数是跟AsyncTask类的创建而执行的

new DownloadFilesTask()

知道了mWorker和mFuture是什么后，我们回到原来的executeOnExecutor()方法，在这里将mWorker的参数传过去后，就开始用线程池execute这个mFuture

mWorker.mParams = params;
exec.execute(mFuture);

一、分析exec

exec是通过executeOnExecutor()参数传进来的

public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
            Params... params)

也就是我们execute()方法传过来的

public final AsyncTask<Params, Progress, Result> execute(Params... params) {
    return executeOnExecutor(sDefaultExecutor, params);
}

这里可以看到exec就是这个sDefaultExecutor

二、分析sDefaultExecutor

我们跟踪这个sDefaultExecutor，截取有关它的代码

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
private static class SerialExecutor implements Executor {
    final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
    Runnable mActive;
    public synchronized void execute(final Runnable r) {
        mTasks.offer(new Runnable() {
            public void run() {
                try {
                    r.run();
                } finally {
                    scheduleNext();
                }
            }
        });
        if (mActive == null) {
            scheduleNext();
        }
    }
    protected synchronized void scheduleNext() {
        if ((mActive = mTasks.poll()) != null) {
            THREAD_POOL_EXECUTOR.execute(mActive);
        }
    }
}

从SerialExecutor可以发现，exec.execute(mFuture)就是在调用SerialExecutor类的execute(final Runnable r)方法，这里的参数r就是mFuture

继续往下走，SerialExecutor的execute()方法会将r封装成Runnable，并添加到mTasks任务队列中

继续往下走，如果这时候没有正在活动的AsyncTask任务，那么就会调用SerialExecutor的scheduleNext()方法，来执行下一个AsyncTask任务

if (mActive == null) {
    scheduleNext();
}

继续往下走，通过mTasks.poll()取出，将封装在mTask的Runnable交给mActive，最后真正执行的这个mActive的是THREAD_POOL_EXECUTOR，即执行的这个mActive，也就是包装在Runnable里面的mFuture

protected synchronized void scheduleNext() {
    if ((mActive = mTasks.poll()) != null) {
        THREAD_POOL_EXECUTOR.execute(mActive);
    }
}

mFuture被执行了，也就会执行它的run()方法

public void run() {
    try {
        r.run();
    } finally {
        scheduleNext();
    }
}

我们跟踪到mFuture的run()方法中，切换到FutureTask类

public void run() {
    if (state != NEW ||
        !U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
        return;
    try {
        Callable<V> c = callable;
        if (c != null && state == NEW) {
            V result;
            boolean ran;
            try {
                result = c.call();
                ran = true;
            } catch (Throwable ex) {
                result = null;
                ran = false;
                setException(ex);
            }
            if (ran)
                set(result);
        }
    } finally {
        // runner must be non-null until state is settled to
        // prevent concurrent calls to run()
        runner = null;
        // state must be re-read after nulling runner to prevent
        // leaked interrupts
        int s = state;
        if (s >= INTERRUPTING)
            handlePossibleCancellationInterrupt(s);
    }
}

这一段代码其实就是将之前在mFutrue创建对象时候传进来的mWorker交给c

Callable<V> c = callable;

然后再调用c的call()方法，也就是mWorker的call()方法

result = c.call();

代码又重新的定位到了mWorker类的call()方法

 mWorker = new WorkerRunnable<Params, Result>() {
    public Result call() throws Exception {
        mTaskInvoked.set(true);
        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
        //noinspection unchecked
        Result result = doInBackground(mParams);
        Binder.flushPendingCommands();
        return postResult(result);
    }
};

可以发现，这里就调用了我们的doInBackground()方法，最后还返回postResult()，我们跟踪这个postResult()方法

private Result postResult(Result result) {
    @SuppressWarnings("unchecked")
    Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
            new AsyncTaskResult<Result>(this, result));
    message.sendToTarget();
    return result;
}

观察代码，首先是getHandler()，它是一个单例，返回sHandler

private static Handler getHandler() {
    synchronized (AsyncTask.class) {
        if (sHandler == null) {
            sHandler = new InternalHandler();
        }
        return sHandler;
    }
}

也就是说postResult方法会通过sHandler发送一个MESSAGE_POST_RESULT的消息，这个时候我们追踪到sHandler

private static InternalHandler sHandler;
private static class InternalHandler extends Handler {
    public InternalHandler() {
        super(Looper.getMainLooper());
    }
    @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
    @Override
    public void handleMessage(Message msg) {
        AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
        switch (msg.what) {
            case MESSAGE_POST_RESULT:
                // There is only one result
                result.mTask.finish(result.mData[0]);
                break;
            case MESSAGE_POST_PROGRESS:
                result.mTask.onProgressUpdate(result.mData);
                break;
        }
    }
}

可以发现，sHandler收到MESSAGE_POST_PROGRESS消息后会调用result.mTask.finish(result.mData[0])，那么我们还必须知道result是个什么东西

AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;

result是AsyncTask的内部类，实际上就是个实体类，用来存储变量的

private static class AsyncTaskResult<Data> {
    final AsyncTask mTask;
    final Data[] mData;
    AsyncTaskResult(AsyncTask task, Data... data) {
        mTask = task;
        mData = data;
    }
}

result.mTask也就是AsyncTask，最后调用result.mTask.finish(result.mData[0])，即AsyncTask的finish()方法，我们跟踪到finish()方法

private void finish(Result result) {
    if (isCancelled()) {
        onCancelled(result);
    } else {
        onPostExecute(result);
    }
    mStatus = Status.FINISHED;
}

这里判断AsyncTask是否已经取消，如果不取消就执行我们的onPostExecute()，最后将状态设置为FINISHED，整一个AsyncTask的方法都执行完了，我们只需要继承AsyncTask实现其中的方法就可以按分析的顺序往下执行了

次分支部分
在AsyncTask中的finish()方法，我们可以看到onCancelled()方法跟onPostExecute()一起的，只要isCancelled()的值为true，就执行onCancelled()方法

private void finish(Result result) {
    if (isCancelled()) {
        onCancelled(result);
    } else {
        onPostExecute(result);
    }
    mStatus = Status.FINISHED;
}

我们代码跟踪isCancelled()方法

public final boolean isCancelled() {
    return mCancelled.get();
}

发现是在mCancelled中获取的，那我们就必须知道这个mCancelled是什么，代码跟踪到mCancelled

private final AtomicBoolean mCancelled = new AtomicBoolean();

mCancelled实际上就是个Boolean对象，那我们搜索它是在哪个时候设置的

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

可以发现，只要我们在AsyncTask类中调用这个方法即可停止异步任务

而onProgressUpdate()方法，是在sHandler中执行，sHandler收到MESSAGE_POST_PROGRESS消息后，执行，我们搜索MESSAGE_POST_PROGRESS在什么时候发送的

private static class InternalHandler extends Handler {
   public InternalHandler() {
        super(Looper.getMainLooper());
    }
    @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
    @Override
    public void handleMessage(Message msg) {
        AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
        switch (msg.what) {
            case MESSAGE_POST_RESULT:
                // There is only one result
                result.mTask.finish(result.mData[0]);
                break;
            case MESSAGE_POST_PROGRESS:
                result.mTask.onProgressUpdate(result.mData);
                break;
        }
    }
}

可以发现，只要我们在AsyncTask类中调用publishProgress()方法即可执行onProgressUpdate()方法

protected final void publishProgress(Progress... values) {
    if (!isCancelled()) {
        getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
                new AsyncTaskResult<Progress>(this, values)).sendToTarget();
    }
}

源码原文：https://blog.csdn.net/qq_30379689/article/details/53203556

说实话上面源码分析写得真好，我在看了上面的源码感觉少了一丢丢东西，自己在额外的补充一点东西

补充：THREAD_POOL_EXECUTOR

/**
  * 源码分析：THREAD_POOL_EXECUTOR.execute（）
  * 说明：
  *     a. THREAD_POOL_EXECUTOR实际上是1个已配置好的可执行并行任务的线程池
  *     b. 调用THREAD_POOL_EXECUTOR.execute（）实际上是调用线程池的execute()去执行具体耗时任务
  *     c. 而该耗时任务则是步骤2中初始化WorkerRunnable实例对象时复写的call（）
  * 注：下面先看任务执行线程池的线程配置过程，看完后请回到步骤2中的源码分析call（）
  */
    // 步骤1：参数设置
        //获得当前CPU的核心数
        private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
        //设置线程池的核心线程数2-4之间,但是取决于CPU核数
        private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
        //设置线程池的最大线程数为 CPU核数*2+1
        private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
        //设置线程池空闲线程存活时间30s
        private static final int KEEP_ALIVE_SECONDS = 30;
        //初始化线程工厂
        private static final ThreadFactory sThreadFactory = new ThreadFactory() {
            private final AtomicInteger mCount = new AtomicInteger(1);
            public Thread newThread(Runnable r) {
                return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
            }
        };
        //初始化存储任务的队列为LinkedBlockingQueue 最大容量为128
        private static final BlockingQueue<Runnable> sPoolWorkQueue =
                new LinkedBlockingQueue<Runnable>(128);
    // 步骤2： 根据参数配置执行任务线程池，即 THREAD_POOL_EXECUTOR
    public static final Executor THREAD_POOL_EXECUTOR;
    static {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                sPoolWorkQueue, sThreadFactory);
        // 设置核心线程池的 超时时间也为30s
        threadPoolExecutor.allowCoreThreadTimeOut(true);
        THREAD_POOL_EXECUTOR = threadPoolExecutor;
    }

还有就是 我们可以通过源码可以知道 使用AsyncTask执行的后台线程只有一个，这个结局看起来很悲伤。我们原以为执行如下。

但是现实是这样子的

被串行设置了 如下 synchronized

private static class SerialExecutor implements Executor {
        // SerialExecutor = 静态内部类
        // 即 是所有实例化的AsyncTask对象公有的
        // SerialExecutor 内部维持了1个双向队列；
        // 容量根据元素数量调节
        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
        Runnable mActive;
        // execute（）被同步锁synchronized修饰
        // 即说明：通过锁使得该队列保证AsyncTask中的任务是串行执行的
        // 即 多个任务需1个个加到该队列中；然后 执行完队列头部的再执行下一个，以此类推
        public synchronized void execute(final Runnable r) {
            // 将实例化后的FutureTask类 的实例对象传入
            // 即相当于：向队列中加入一个新的任务
            mTasks.offer(new Runnable() {
                public void run() {
                    try {
                        r.run();
                    } finally {
                        scheduleNext();->>分析3
                    }
                }
            });
            // 若当前无任务执行，则去队列中取出1个执行
            if (mActive == null) {
                scheduleNext();
            }
        }
        // 分析3
        protected synchronized void scheduleNext() {
            // 1. 取出队列头部任务
            if ((mActive = mTasks.poll()) != null) {
                // 2. 执行取出的队列头部任务
                // 即 调用执行任务线程池类（THREAD_POOL_EXECUTOR）->>继续往下看
                THREAD_POOL_EXECUTOR.execute(mActive);
            }
        }
    }

好吧，我到现在还是没有明白为什么他要如此限制，等哪位小哥哥，知道这个为什么的时候告诉我一声，拜托拜托

如果我们还是想并行执行，参考如下

方法一，绕过 excute 方法避免SerialExecutor 对象

方法二，绕过 excute 方法避免被转换为 自定义线程池

方法三，在excute 方法将默认对象换为我们的 自定义线程池对象

    //自定义线程池
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
    private static final int KEEP_ALIVE_SECONDS = 60;
    public static final Executor MY_THREAD_POOL_EXECUTOR;
    private static final ThreadFactory sThreadFactory = new ThreadFactory() {
        private final AtomicInteger mCount = new AtomicInteger(1);
        @Override
        public Thread newThread(Runnable r) {
            return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
        }
    };
    private static final BlockingQueue<Runnable> sPoolWorkQueue =
            new LinkedBlockingQueue<Runnable>(128);
    static {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                sPoolWorkQueue, sThreadFactory);
        threadPoolExecutor.allowCoreThreadTimeOut(true);
        MY_THREAD_POOL_EXECUTOR = threadPoolExecutor;
    }
 case R.id.btAsyncTaskSerial://串行执行
                new MyAsyncTask(mActivity, "Task#1 ").execute("123");
                new MyAsyncTask(mActivity, "Task#2 ").execute("123");
                new MyAsyncTask(mActivity, "Task#3 ").execute("123");
                break;
            case R.id.btAsyncTaskParallel://并行执行 -- 这里使用 AsyncTask 自带的线程池
                new MyAsyncTask(mActivity, "Task#1 ").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "123");
                new MyAsyncTask(mActivity, "Task#2 ").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "123");
                new MyAsyncTask(mActivity, "Task#3 ").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "123");
                break;
            case R.id.btAsyncTaskParallelByUs://并行执行 -- 自定义线程池
                new MyAsyncTask(mActivity, "Task#1 ").executeOnExecutor(MY_THREAD_POOL_EXECUTOR, "123");
                new MyAsyncTask(mActivity, "Task#2 ").executeOnExecutor(MY_THREAD_POOL_EXECUTOR, "123");
                new MyAsyncTask(mActivity, "Task#3 ").executeOnExecutor(MY_THREAD_POOL_EXECUTOR, "123");
                break;
            case R.id.btAsyncTaskParallelByUs2://并行执行 -- 自定义线程池 另外一种方式
                MyAsyncTask.setDefaultExecutor(MY_THREAD_POOL_EXECUTOR);//替换掉默认的  AsyncTask.SERIAL_EXECUTOR
                new MyAsyncTask(mActivity, "Task#a ").execute("abc");
                new MyAsyncTask(mActivity, "Task#b ").execute("abc");
                new MyAsyncTask(mActivity, "Task#c ").execute("abc");
                break;

重要的事再次强调我到现在还是没有明白为什么他要如此限制，等哪位小哥哥，知道这个为什么的时候告诉我一声，拜托拜托

Thanks

https://github.com/javakam/IShiQing/blob/38987a427d8b376333259aef48f13977f5c08b69/app/src/main/java/com/ishiqing/modules/thread/AsyncTaskFragment.java

https://www.jianshu.com/p/37502bbbb25a

https://blog.csdn.net/qq_30379689/article/details/53203556

最新文章 相关文章

adb push命令向设备传输文件的操作步骤

目录一、向设备传输文件命令二、操作步骤2.1 连接设备2.2 启动windows的cmd2.3 输入adb push指令三、总结一、向设备传输文件命令用于在windows系统下，向设备传输文件。二、

2024-06-09 01:14:15

Android自定义实现转盘菜单

目录一、前言二、绘制原理三、总结一、前言旋转菜单是一种占用空间较大，实用性稍弱的UI，一方面由于展示空间的问题，其展示的数据有限，但另一方面真由于这个原因，对用户而言趣味性

2024-06-09 01:14:12

Android使用SqLite实现登录注册功能流程详解

目录一、了解什么是Android Studio二、了解什么是sqlite三、创建项目文件四、创建活动文件和布局文件五、创建数据库连接数据库六、创建实体类实现注册功能七、实现登录功能

2024-06-09 01:14:09

Android大图监测系统的三种实现方式

目录原理解析主动监测被动监测在第三方图片加载库回调中进行大图监测在网络加载图片时进行大图监测使用ASM插桩进行大图监控注意事项与优化技巧总结原理解析内存占用计算首

2024-06-09 01:14:05

详细讲解AsyncTask使用说明(值得收藏)

目录概念类简介简单例子执行流程一、在执行完 AsyncTask.excute() 后二、方法分析源码分析一、主分支二、次分支主分支部分一、分析mWorker二、分析mFuture三、回过头来看一

2024-06-09 01:14:03

Kotlin 协程的异常处理准则

目录Kotlin 协程的异常处理概述异常处理六大准则准则一：协程的取消需要内部配合问题：cancel不被响应解决：使用 isActive 判断是否处于活跃状态准则二：不要打破协程的父子结构问

2024-06-09 01:14:00

Android 双屏异显自适应Dialog的实现

目录一、前言需求问题二、方案方案：自定义Presentation原理WindowType问题解决WindowManagerImpl 问题方案：Delagate方式：兼容总结一、前言Android 多屏互联的时代，必然会出现多

2024-06-09 01:13:57

Android实现录音监听动画的示例代码

目录一、前言二、实现方法三、全部代码四、总结一、前言在很多app种内置了语音助手，也存在各种动画，主要原因是处理2个阶段问题，第一个是监听声音的等待效果，第二个是语意解析存

2024-06-09 01:13:55

Flutter路由的几种用法小结

目录Flutter路由跳转基本路由跳转 返回上一页路由基本路由跳转传参命名路由跳转命名路由跳转需要先配置路由命名路由跳转传参命名路由替换跳转移除所有页面返回到根页面Flut

2024-06-09 01:13:52

Android图片描边效果的实现

目录前言提取蒙版蒙版绘制扩大蒙版（影子）闪烁效果总结全部代码前言先看下我们阔爱滴海绵宝宝，其原图是一张PNG图片，我们给宝宝加上描边效果，今天我们使用的是图片蒙版技术。说到

2024-06-09 01:13:50

Android EditText设置边框的操作方法

目录Android EditText设置边框简介快速开始Android EditText设置边框简介Android应用程序中给EditText设置边框。效果图：快速开始1.在res/drawable目录下新建样式文件 edit_b

2024-06-09 01:13:47

Qt6.5.3 Android环境配置的实现

目录前言安装Qt安装JDK配置环境问题解决SDK配置报错：&times; Android SDK Command-line Tools runsQt版本出现错误：无法检测 Qt 版本所使用的 ABI。安卓构建套件警告：no device

2024-06-09 01:13:44

Flutter使用stack实现悬浮UI的示例代码

目录stack特性示例stack特性在Flutter中，你可以使用Stack和Positioned来创建悬浮 UI。Stack允许你将多个小部件叠放在一起，而Positioned则用于定位小部件在Stack中的位置。示

2024-06-09 01:13:42

OkHttp原理分析小结

目录Okhttp 介绍Okhttp 中几个重要类的介绍OkHttpClientOkHttpClient使用注意OkHttpClient的创建不需要了可以关闭Call 类Request 类RequestBody总结一下OKHTTP架构图OKHttp

2024-06-09 01:13:39

Android车载空调系统（HVAC）开发方法分析

目录1. HVAC 功能介绍1.1 双区温度调节1.2 空调开关1.3 内/外循环1.4 风量调节1.5 风向调节1.6 A/C开关1.7 主副驾座椅加热1.8 除霜1.9 自动模式2. HVAC 源码结构3. HVAC 核

2024-06-09 01:13:36

基于Android实现自动滚动布局

目录前言1. 布局自动滚动的思路2. 最终效果3. 代码实现4. 总结前言在平时的开发中，有时会碰到这样的场景，设计上布局的内容会比较紧凑，导致部分机型上某些布局中的内容显示不完

2024-06-09 01:13:34

Flutter BuildContext功能使用详解

目录BuildContext 简介BuildContext的主要作用BuildContext 简介BuildContext是Flutter中的一个重要概念，表示当前Widget在树中的位置上下文。它是一个对Widget树的一个位置

2024-06-09 01:13:26

Android apk完整性检测的实现思路和代码实现

目录需求和背景实现安全管理类相关工具类需求和背景行业相关，对安全性较高的程序一般都需要添加完整性检测的功能，以防止程序被篡改，从而导致安全问题的发生。
相关的支付应用

2024-06-09 01:13:24

Android Studio开发中Gradle各种常见报错问题解决方案

目录Android开发各种Gradle错误缺少依赖项版本冲突配置错误Android开发各种Gradle错误在开发Android应用程序时，我们可能会遇到各种Gradle错误。这些错误可能来自不同的原因，

2024-06-09 01:13:22

Flutter框架实现Android拖动到垃圾桶删除效果

目录Draggable介绍构造函数参数说明使用示例DragTarget介绍构造函数参数说明使用示例DragTarget如何接收Draggable传递过来的数据结束语Draggable介绍Draggable是Flutter框

2024-06-09 01:13:20

Android 中的 XRecyclerview的使用案例

目录前言：步骤：引用库实战过程我的案例前言：我们在上一篇文章中学到了Recyclerview但是在现实中往往需求不是那么的简单，可能需要多种需求合并起来，例如常见的上下拉刷新，删除 ite

2024-06-09 01:13:18

Android滑动冲突的解决技巧

目录滑动冲突的原理解决方法外部拦截法内部拦截法注意事项和优化技巧总结滑动冲突的原理Android的事件分发机制是基于ViewGroup的。当用户在屏幕上触摸时，事件会首先传递给最

2024-06-09 01:13:16

Android自定义View实现两种二维码的扫描效果

目录背景横线效果网格效果基础属性绘制背景色绘制边框线绘制四个边角线扫描线绘制及移动特点背景最近在开发新项目时，使用了扫描二维码的功能，一般扫描二维码的效果是一条横线

2024-06-09 01:12:49

Android中的HTextView库实现TextView动画效果

目录HTextView前言HTextView的简单使用方法HTextView引入line使用以及效果fade使用以及效果typer使用以及效果rainbow使用以及效果scale使用以及效果evaporate使用以及效果f

2024-06-09 01:12:45

Android应用设置独立的多语言实战技巧详解

目录应用设置一个不同于全局的多语言系统设置中支持为应用设置单独多语言入口在哪里自动添加手动添加在应用内部设置多语言应用设置一个不同于全局的多语言通常情况下多语言

2024-06-09 01:12:43

Flutter fluro时报错type &apos;String&apos; is not a subtype of type &ap

目录报错错误原因解决方法序列化和反序列化结语报错使用fluro时报错type &lsquo;String&rsquo; is not a subtype of type &lsquo;Queue<Task>&rsquo;报错如下：错误原因在使

2024-06-09 01:12:41

Kotlin 协程 supervisorScope {} 运行崩溃解决方法

目录Kotlin 协程 supervisorScope {} 运行崩溃解决前言解决方法kotlin 协程异常处理Kotlin 协程 supervisorScope {} 运行崩溃解决前言简单介绍supervisorScope函数，它用于创

2024-06-09 01:12:38

Android ADB简介、安装及使用详解

目录一、ADB简介1、什么是adb2、为什么要用adb二、准备工具1、下载adb2、配置环境变量3、连接 4、电脑打开cmd窗口三、ADB命令详解1、基本命令2、权限命令 3、建立连接4、ap

2024-06-09 01:12:36

解决Android SELinux权限问题记录分析

目录引言解决上下文问题上下文类型引言我在恢复安卓Termux数据时遇到了权限问题，我将数据恢复到/data/data目录中，并用chown设置了正确的用户和组，但是Termux在访问时还是遇到

2024-06-09 01:12:32

Android中注解处理器APT用法示例

目录APT作用Android基本编译流程APT基本使用1、 自定义注解2、注解处理器注解处理器注解处理器注册java代码生成3. 对外调用4. 调用总结APT，Annotation Processing Tool，即注

2024-06-09 01:12:30

热点内容

Flutter项目在 iOS14 启动崩溃的解决方法
2020-09-23
Android解决getExternalStorageDirectory在29后废弃问题(推荐)
2021-02-18
Android Studio连接MySql实现登录注册(附源代码)
2021-05-16
Android串口通信apk源码详解(附完整源码)
2021-01-19
解决flutter 错误: 程序包androidx.lifecycle不存在问题
2020-10-14
Flutter 实现进度条效果
2020-05-18
解决Android调用系统分享给微信,出现分享失败,分享多文件必须为图片格式的问题
2020-10-14
Android Tablayout 自定义Tab布局的使用案例
2020-10-14
Android studio listview实现列表数据显示 数据循环显示效果
2020-10-14
关于android studio升级4.1 某些插件使用不了的问题(Mac)
2020-10-23
返回顶部
顶部