AsyncTask研究(以Android 10.0为准)

Android最全最简单的异步任务AsyncTask使用解析 Android最全最简单的异步任务AsyncTask使用解析.一步到位彻底理解异步任务。 立即下载

1. AsyncTask概述

在Android平台上,要执行异步工作时,我们常常会用到AsyncTask。这个类可以算是历史悠久,早在Android 1.5版时,它就存在了。

AsyncTask的使用方法比较简单,无非是创建一个AsyncTask派生类对象,重写其doInBackground()函数,然后在合适时机调用这个对象的execute()或executeOnExecutor()函数即可。下面是一段简单的示例代码:

private static class MyTask extends AsyncTask<Void, Void, Void> {
    // . . . . . .
    @Override
    public Void doInBackground(Void... param) {
        //. . . . . .
        return null;
    }
}
private class TestClickListener implements View.OnClickListener {
    public void onClick(View v) {
        switch (v.getId()) {
        case R.id.scan_btn:
            testTask();
            break;
        . . . . . .
    }
            
    private void testTask() {
        for (int i = 0; i < 5; i++) {
            MyTask t = new MyTask(i+100);
            t.execute();    // 在UI线程里,调用execute()即可
        }
    }

一般情况下,我们会像上面代码中这样调用AsyncTask的execute()函数,这样,投入执行的task会串行执行。不过,有时候我们也希望task们可以并行执行,此时只需把execute()换成executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR)即可。

需要注意的是,AsyncTask的execute()只能在UI线程里调用,所以上面示例代码里,我们是在响应控件点击动作的onClick()函数里调用t.execute()的。

2. AsyncTask的内部机制

AsyncTask本身是个抽象的泛型基类,正如前面所说,在实际使用时,我们必须定义它的派生类,并在实现AsyncTask派生类时,重写其doInBackground()成员函数。示意图如下:


AysncTask的声明如下:
【frameworks/base/core/java/android/os/AsyncTask.java】

public abstract class AsyncTask<Params, Progress, Result> 

作为一种异步执行的任务,AsyncTask是依靠内部的线程池来完成任务调度的。大体上说,AsyncTask内部搞了两个静态的执行器,分别表示成AsyncTask.THREAD_POOL_EXECUTOR 和 AsyncTask.SERIAL_EXECUTOR,前者是可并行执行的执行器(线程池),后者是串行执行的执行器(线程池)。

在目前的代码中,AsyncTask的构造函数有几种形式,只不过带参数的形式都是隐藏接口,第三方应用是不能直接使用的。默认的无参形式如下:

/**
 * Creates a new asynchronous task. This constructor must be invoked on the UI thread.
 */
public AsyncTask() {
    this((Looper) null);
}

隐藏的有参形式如下:

/**
 * Creates a new asynchronous task. This constructor must be invoked on the UI thread.
 * @hide
 */
public AsyncTask(@Nullable Handler handler) {
    this(handler != null ? handler.getLooper() : null);
}

一般来说,可以携带handler参数的函数,都可以将后续的回调处理放到某个工作线程执行,这至少可以减轻UI线程的一些负担。只可惜这个构造函数是@hide的。

前两种构造函数最终都会用到下面这个隐藏的构造函数:
【frameworks/base/core/java/android/os/AsyncTask.java】
 

/**
 * Creates a new asynchronous task. This constructor must be invoked on the UI thread.
 * @hide
 */
public AsyncTask(@Nullable Looper callbackLooper) {
    mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
        ? getMainHandler()
        : new Handler(callbackLooper);

    mWorker = new WorkerRunnable<Params, Result>() {
        public Result call() throws Exception {
            mTaskInvoked.set(true);
            Result result = null;
            try {
                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                //noinspection unchecked
                result = doInBackground(mParams);
                Binder.flushPendingCommands();
            } catch (Throwable tr) {
                mCancelled.set(true);
                throw tr;
            } finally {
                postResult(result);
            }
            return 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);
            }
        }
    };
}

构造函数的注释中说的很明确,必须在UI线程里构造AsyncTask对象。而且构造函数里为两个重要的成员:mWorker和mFuture赋了值。AsyncTask本身是泛型化的,其泛型参数Param、Result会进一步确定mWorker和mFuture的最终类型(即WorkerRunnable<Params, Result>和FutureTask<Result>),另一个泛型参数Progress会用于确定“和任务进度相关的函数”,比如AsyncTask的onProgressUpdate()和publishProgress()。有关这部分的细节,我们后文再细说。

2.1 AsyncTask的execute()

我们先回过头看前文曾经提到的AsyncTask的execute()函数,其代码如下:
【frameworks/base/core/java/android/os/AsyncTask.java】

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

因为params参数是可变长参数,所以execute()可以接受0到n个参数。

execute()只是简单地调用executeOnExecutor()而已,正如我们前文所说,execute()(以及executeOnExecutor())都必须在UI线程里调用。传给executeOnExecutor()的参数sDefaultExecutor是个静态变量,它引用的就是串行执行器AsyncTask.SERIAL_EXECUTOR:

private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

executeOnExecutor()的代码截选如下:
【frameworks/base/core/java/android/os/AsyncTask.java】

@MainThread
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
        Params... params) {
    . . . . . .
    . . . . . .
    mStatus = Status.RUNNING;
    onPreExecute();
    mWorker.mParams = params;
    exec.execute(mFuture);  // 注意,mFuture本身实现了Runnable接口,类型为FutureTask<Result>
    return this;
}

可以看到,在UI线程里,我们最终是在调用执行器的execute()函数,只不过会把一个mFuture对象委托给执行器去回调而已。这个执行器可以是串行的,也可以是并行的。mFuture的类型为FutureTask<Result>,而且间接实现了Runnable接口。

默认情况下使用的是串行执行器,其类是SerialExecutor,它的代码如下:
【frameworks/base/core/java/android/os/AsyncTask.java】

private static class SerialExecutor implements Executor {
    final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();  // task队列
    Runnable mActive;  // 用mActive来控制串行行为

    public synchronized void execute(final Runnable r) { // 参数r一般就是mFuture引用的对象
        mTasks.offer(new Runnable() {
            public void run() {
                try {
                    r.run();
                } finally {
                    scheduleNext();  // 每当一个task的mFuture.run()返回,会接着调度下一个
                }
            }
        });
        if (mActive == null) {  // 每次向mTasks队列里添加完新节点后,会先判断mActive,只有
                                // 无事可做时,才会scheduleNext()。
            scheduleNext();
        }
    }

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

从代码里可以看到,所谓的串行执行器内部,其实也是在复用THREAD_POOL_EXECUTOR,只不过通过对mActive的判断,把调用的流程改成串行的了。

SerialExecutor内部使用的是java.util.ArrayDeque队列,它的poll()函数可以检索并移除此队列的头部,如果返回null,则表示此队列已经取空了。每次摘取一个列头,并记录在mActive变量里,然后交给THREAD_POOL_EXECUTOR来处理。

ThreadPoolExecutor是java提供的线程池实现。线程池会在后续的某个时刻,回调上面插入的Runnable对象的run()。在executeOnExecutor()函数里,我们已经看到向执行器添加了AsynctTask的mFuture成员,而mFuture本身实现了Runnable接口,以后回调就是回调mFuture的run()函数。

2.2 AsyncTask和线程池的协作

2.2.1 AsyncTask里的mFuture

AsyncTask的mFuture非常重要,它的定义如下:

private final FutureTask<Result> mFuture;

类型为FutureTask,其实现可以参考JDK里的代码:
【java/util/concurrent/FutureTask.java】

public class FutureTask<V> implements RunnableFuture<V> 

【java/util/concurrent/FunnableFuture.java】

public interface RunnableFuture<V> extends Runnable, Future<V>

在前文列出AsyncTask构造函数时,我们已经看到mFuture的创建代码了,

mFuture = new FutureTask<Result>(mWorker)

注意,在创建FutureTask对象时,传入了mWorker,它会被记入mFuture内部(如果分析JDK的代码,可以看到大体上就是记入mFuture.sync.callable了)。后续在被线程池执行时,这个mWorker才是最核心的对象。

欲了解详情,我们先得看看AsyncTask机制运用的线程池。在AsyncTask类里这样定义线程池成员的:
【frameworks/base/core/java/android/os/AsyncTask.java】

public static final Executor THREAD_POOL_EXECUTOR;

static {
    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
            CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
            // 同步队列已经不是以前的BlockingQueue<Runnable>了
            new SynchronousQueue<Runnable>(), sThreadFactory);  
    threadPoolExecutor.setRejectedExecutionHandler(sRunOnSerialPolicy);  // 设置拒绝策略
    THREAD_POOL_EXECUTOR = threadPoolExecutor;
}

注意,线程池都是记在静态变量里的,它的生命期和进程的生命期基本一致。

细心的同学还记得,前文在定义AsyncTask派生类时,我们写的是private static class,大家不要忘记加static,否则就是写了一个普通内嵌类,而普通内嵌类对象内部会隐式地引用其外部类对象,这样当我们的task对象记入线程池后,就有可能导致task的外部类(很有可能是个Activity或Service)对象在较长时间内都不能被垃圾回收机制回收,从而导致内存泄漏。

还有一点要说明一下,以前(比如Android 7上),线程池使用的“待处理工作队列”是BlockingQueue<Runnable>形式的,而到了Android 10上,则变成了SynchronousQueue。这会导致线程池有什么不同吗?我们可以这样理解,SynchronousQueue的内部是没有任务缓存队列的,所以当CorePool线程用完后,其实是立即起新线程来做事的,直到线程数达到MAXIMUM_POOL_SIZE。这就不像以前那样,还有个填充任务队列的过程。在线程数达到MAXIMUM_POOL_SIZE之后,如果还有新任务,则会按拒绝策略处理。

本文的重点并不想太深入线程池的内部机理,我们只做必要的探讨即可。我们大体上只需知道线程池里的线程会执行FutureTask的run()函数即可。而FutureTask的run()代码如下:
【java/util/concurrent/FutureTask.java】

public void run() {
    sync.innerRun();
}

而FutureTask.Sync的innerRun()代码如下:

void innerRun() {
    if (!compareAndSetState(READY, RUNNING))
        return;

    runner = Thread.currentThread();
    if (getState() == RUNNING) { // recheck after setting thread
        V result;
        try {
            result = callable.call();  // 这一步间接调用到AsyncTask的doInBackground()。
        } catch (Throwable ex) {
            setException(ex);
            return;
        }
        set(result);  // 如果不出异常的话,会对call返回的结果执行set()操作。
    } else {
        releaseShared(0); // cancel
    }
}

其中会调用callable.call(),这一步就会间接调用到AsyncTask的doInBackground()。再接下来,如果不出异常的话,会对call()返回的结果执行set()操作。大家还记得前文WorkerRunnable实现的call()函数吗?它返回的Result对象,归根溯源就是doInBackground()返回的那个Result对象。现在对这个Result对象执行set()操作。

FutureTask的set()函数的代码如下:
【java/util/concurrent/FutureTask.java】

protected void set(V v) {
    sync.innerSet(v);
}
    void innerSet(V v) {
        for (;;) {
            int s = getState();
            if (s == RAN)
                return;
            if (s == CANCELLED) {
                releaseShared(0);
                return;
            }
            if (compareAndSetState(s, RAN)) {
                result = v;
                releaseShared(0);
                done();   // 回调到AsyncTask的mFuture的done()函数
                return;
            }
        }
    }

结果记录进Sync类的result成员,然后回调FutureTask的done()函数,这也就回调到前文我们看到的AsyncTask的mFuture的done()函数了。我们再列一下mFuture的代码:
【frameworks/base/core/java/android/os/AsyncTask.java】

    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);
            }
        }
    };

done()里面会做一些善后处理。

private void postResultIfNotInvoked(Result result) {
    final boolean wasTaskInvoked = mTaskInvoked.get();
    if (!wasTaskInvoked) {
        postResult(result);
    }
}

一般情况下,上面的mTaskInvoked变量会在AsyncTask的mWorker的call()函数中设置为true,所以在mFuture的done()函数中读到的mTaskInvoked还会是为true,于是postResultIfNotInvoked()就直接返回了;而如果其值为false,说明这个任务很可能在线程池回调它之前就被cancel了,也就是说还没轮到call()执行就被取消了,此时call()里面的postResult(result)当然还没有执行过,我们在这里要补救性地调用一次postResult(result)。当然,这种情况比较少见。

我们画一张调用关系示意图:


2.2.2 AsyncTask里的mWorker

AsyncTask的mWorker和mFuture是紧密配合的。mWorker的定义如下:

private final WorkerRunnable<Params, Result> mWorker;

除了在executeOnExecutor()里会为mWorker的mParams成员赋值外,AsyncTask一般不会直接操作mWorker。mWorker会间接记录进mFuture。如前文所述,当mFuture被回调时,系统会间接回调mWorker的call()成员函数,而这个call()函数是整个AsyncTask的核心行为。

现在我们可以画一张AsyncTask的示意图:


其实,当一个AsyncTask被安插进线程池时,线程池主要关心的是其mFuture成员引用的FutureTask。所以我们可以画出如下示意图:

当回调发生时,最终间接执行到mWorker成员的call()函数,在介绍AsyncTask的构造函数时,我们已经见过该函数的代码,现在再列一遍:

    mWorker = new WorkerRunnable<Params, Result>() {
        public Result call() throws Exception {
            mTaskInvoked.set(true);
            Result result = null;
            try {
                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); // 后台线程
                //noinspection unchecked
                result = doInBackground(mParams);
                Binder.flushPendingCommands();
            } catch (Throwable tr) {
                mCancelled.set(true);
                throw tr;
            } finally {
                postResult(result);
            }
            return result;
        }
    };

看到了吗,当线程池里的某个线程回调到上面的call()函数时,会先把线程优先级设置为“后台线程”,然后再调用doInBackground()函数。大家还记得吧,前文说过我们在实现一个AsyncTask派生类时,主要重写的就是这个doInBackground()函数,现在终于派上用场了。

上面代码中还调用了一个不常见的函数:Binder.flushPendingCommands()。这个函数对应的注释是这样说的:(本函数)会将所有在当前线程里挂起的“Binder命令”扔回内核驱动。一般可以在执行那些有可能阻塞较长时间的操作之前调用一下该函数,这样可以确保挂起的对象引用被及时释放,避免“持有执行对象的进程”占据比“实际需要持有的时间”更长的时间。这部分说明让人有点儿迷惑,或许此处的调用仅仅只是为了在doInBackground()之后做一些binder驱动层的清理动作。

2.2.3 UI线程和AsyncTask工作线程之间的协作

前文我们已经看到,回调的call()函数最终会通过postResult(),发回一条MESSAGE_POST_RESULT消息。postResult()的代码如下:
【frameworks/base/core/java/android/os/AsyncTask.java】

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

在Android 7上,getHandler()拿到的是AsyncTask的静态成员sHandler,可以向UI线程发送消息。但到了Android 10上,至少在frameworks内部是可以指定Looper的,那么就不一定是向UI线程发送消息啦,也有可能向其他工作线程发送消息。我再摘录一下前文AsyncTask构造函数里关于mHandler的句子:

mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
    ? getMainHandler()
    : new Handler(callbackLooper);

在Android10上,getHandler()的代码很简单:

private Handler getHandler() {
    return mHandler;
}

当然,在大多数情况下,getHandler()拿到的handler是向UI线程发消息的,其具体值来自于getMainHandler():

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

这里搞了个类似单例的sHandler,类型为InternalHandler:

private static class InternalHandler extends Handler {
    public InternalHandler(Looper looper) {
        super(looper);
    }

    @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;
        }
    }
}

因为在new InternalHandler()时传入的looper就是UI线程looper,所以其实就是在UI线程处理MESSAGE_POST_RESULT消息的,而且处理时会调用AsyncTask的finish()。

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

从这段代码可以知道,如果我们cancel了某个AsyncTask,就不会执行onPostExecute()了,取而代之的是调用onCancelled()。

另一方面,用户在编写doInBackground()时,还可以在合适时机调用publishProgress(),向UI线程发出MESSAGE_POST_PROGRESS消息。publishProgress()的代码如下:

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

这个消息同样被刚刚说到的InternalHandler处理,处理时会回调AsyncTask的onProgressUpdate()。

关于UI线程和执行AsyncTask的线程之间的交互,我们可以画一张示意图如下:

这张图反映了一个AsyncTask对象在运作时,大体上是如何被UI线程和工作线程调用执行的。

2.2.4 AsyncTask的内部状态

细心的读者还会发现,AsyncTask在finish()时会把自己的状态置为Status.FINISHED。简单说来,AsyncTask可以处于3种状态,分别是PENDING、RUNNING、FINISHED。这3种状态的切换很简单,示意图如下:


2.2.5 cancel动作

一般情况下,异步任务中常常要进行比较耗时的操作,比如从网络加载一些数据。但我们必须考虑到,在网络不佳的情况下,用户有可能会等不及,此时用户应该有权力取消这个任务。也就是说,用户应该可以随时中途放弃执行当前任务。不管是在主线程处理MESSAGE_POST_PROGRESS时,还是在工作线程处理doInBackground()时,用户都可以调用AsyncTask的cancel()函数。该函数的代码如下:
【frameworks/base/core/java/android/os/AsyncTask.java】

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

其中第一步就是在设置mCancelled变量,而第二步mFuture.cancel()内部会在mayInterruptIfRunning参数为true时,间接调用“运行该AsyncTask的线程”的interrupt()函数。

【java/util/concurrent/FutureTask.java】

public boolean cancel(boolean mayInterruptIfRunning) {
    return sync.innerCancel(mayInterruptIfRunning);
}

【java/util/concurrent/FutureTask.java】

boolean innerCancel(boolean mayInterruptIfRunning) {
    for (;;) {
        int s = getState();
        if (ranOrCancelled(s))
            return false;
        if (compareAndSetState(s, CANCELLED))
            break;
    }
    if (mayInterruptIfRunning) {
        Thread r = runner;
        if (r != null)
            r.interrupt();
    }
    releaseShared(0);
    done();
    return true;
}

简单地说,cancel()动作会将mCancelled设为true,这样以后再调用isCancelled()时,就会返回true。前文我们已经看过AsyncTask的finish()的代码,现在再列一下:

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

可以看到,如果该任务是被用户cancel的,那么finish时执行的会是onCancelled(),而不是onPostExecute()。另外,为了确保在用户cancel任务之后,该任务能真的快速退出,我们应该在doInBackground()里周期性地检查一下isCancelled()的返回值,一旦发现任务已经取消了,就请立即退出。

3 小结

关于AsyncTask的知识,我们就先说这么多。现在大体总结一下:
1)使用AsyncTask时,主要是重写其派生类的doInBackground(),而且该函数会在线程池的某个工作线程里被回调的;
2)必须在UI线程调用AsyncTask的execute()或executeOnExecutor();
3)AsyncTask默认是按后台优先级(THREAD_PRIORITY_BACKGROUND)在线程池中执行的,如果你尝试做一些重要的工作,那么可能会面临抢不到CPU资源而执行缓慢的情况。
4)可以在doInBackground()里的合适时机调用publishProgress(),向UI线程通知工作进展;
5)可以随时调用cancel(),放弃执行任务。
 

Vivado IP核与约束文件管理指南:解决OOC警告、COE文件丢失与Block Design复用 本文详细介绍了Vivado IP核与约束文件管理的系统化方法,包括解决OOC警告、COE文件丢失与Block Design复用等常见问题。通过IP核锁定机制、分层约束架构和动态约束技术,提升FPGA工程的健壮性和团队协作效率,特别适合中大型项目开发。 阅读详情

相关推荐

用Arduino和RC522模块DIY一个NFC门禁卡复制器(附完整代码)

本文详细介绍了如何利用Arduino和RC522模块DIY一个NFC门禁卡复制器,包括硬件连接、软件配置、数据读写技术及完整代码实现。通过本教程,电子爱好者可以深入了解NFC技术,并构建自己的智能门禁系统,适用于家庭安全、办公场所等多种场景。

weixin_33704591的博客 505

AsyncTask不为人知的那些事

作为java转android的一员,在入android之初,我通常使用thread+handler的方式处理异步线程后台等操作。后来接触了AsyncTask这个神奇的类,开始觉得很好用,后来才发现遇到无数个坑,今天就给大家分享一下经验,怎么避免这些。AsyncTask官方文档解读 AsyncTask介绍   AsyncTask是一个Android SDK中轻量级的异步任务类,它

被欺诈的青春 1854

使用python获取同花顺免费版和同花顺远航版自选股数据用于量化交易

在做量化交易时,有时需要在盘中实时监控同花顺自选股的数量,以便灵活地自定义提醒、捕捉买卖时点等。那么,如何使用python获取同花顺自选股数据呢?

tzzqn2008的专栏 3689

Android之AsyncTask源码分析(第四篇:执行任务过程)

(注意:本文基于API 28的源码分析,API 29上或其他平台的源码略有不同) 调用AsyncTask的execute方法后,onPreExecute、doInbackground、onPostExecute,调用顺序源码解读 0、 ...

王员外的博客 532

Cadence学习之路(六)元器件封装绘制

使用Allegro PCB Designer绘制元器件封装

qq_46757048的博客 1万+

为什么你的Nginx配置SM2国密SSL证书失败?这些坑我都帮你踩过了

本文针对Nginx配置SM2国密SSL证书的常见失败原因,提供了详细的排查与解决方案。核心在于使用支持国密算法的Nginx版本(如集成Tongsuo库),正确处理从阿里云等平台获取的证书格式,并正确配置ssl_ciphers等关键参数。文章还解释了浏览器兼容性差异及双证书部署等进阶场景,帮助运维和开发人员高效完成国密合规改造。

weixin_29228203的博客 388

Android O - java.lang.RuntimeException: An error occurred while executing doInBackground()

最近任务列表中多了一个bug,让在这个sprint中解决掉,bug的堆栈信息如下: Fatal Exception: java.lang.RuntimeException: An error occurred while executing doInBackground() at android.os.AsyncTask$3.done(AsyncTask.java:353) ...

周将的博客 1万+

【C#程序员入门AI】必知的一些知识

2026年C#调用AI,核心就4个概念+3种方式4个概念:大模型(大脑)、嵌入(数字密码)、向量(载体)、Agent(超级助理)3种方式:云端API(快)、本地模型(隐私)、混合部署(最佳)不用怕复杂,跟着这个思路走,你就能从“AI小白”变成“C# AI开发能手”,把AI集成到你的.NET项目里,提升效率、创造价值!

人工智能AI技术 410

安卓AsyncTask使用

安卓AsyncTask使用

似霰的博客 1413

在 SAP BTP ABAP 环境中测试多租户 SaaS 解决方案的完整实践指南

ABAP SaaS测试阶段关键实践 在SAP BTP ABAP环境中开发多租户SaaS解决方案时,测试阶段(TST)对确保产品质量尤为关键。测试阶段应包含两个主要维度: 业务功能验证: 通过软件组件管理确保测试环境与代码仓库同步 创建并验证业务角色分配,确保权限配置正确 测试Fiori Launchpad导航流程和跨应用跳转 验证inbound/outbound通信配置 自动化质量管控: 在开发环境(DEV)执行本地ATC检查和单元测试 通过ABAP Test Cockpit(ATC)进行代码质量检查 集成

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 298

OpenClaw 报错 npm install failed; cleaning up and retrying...:原生模块编译失败

本文针对OpenClaw项目在部署时出现的"npm install failed"报错问题进行分析,指出该问题源于Node.js原生模块编译链缺失。文章详细列举了常见触发原因,包括缺少gcc/make、Python版本不符、Node版本过新等,并提供了五种解决方案:安装完整编译环境、配置node-gyp Python、重新编译原生模块、切换Node版本以及单独重建失败模块。最后强调在国产服务器环境下部署AI工程时,补齐编译环境和使用稳定Node版本是解决问题的关键,该方案可复用解决

博客 1803

Android 异步任务:AsyncTask机制 源码详细版解析------从入门到升天

相信大家对**AsyncTask机制**都不陌生?基本的使用的方法和注意事项都清楚,编写一个类,继承AsyncTask类,必须重写**doInBackground()**方法,运行在**子线程**,耗时的操作在此执行;**onPostExecute()**方法在**doInBackground()**执行完**后**被回调,运行在**主线程**,可进行**UI更新**;若需要显示**更新**的进度,可重写**onPr

lemonGuo的大脑皮层、小脑、海马体、杏仁核..... 2576

【Claude】组织级认证限制报错已解决(4 种)

报错被禁用的是什么谁能解除应急方案整个 Console 组织Anthropic 支持换账户 / 订阅凭证API key 认证方式你的组织管理员用订阅/login订阅 OAuth 登录你的组织管理员用 API keyRoutines 功能你的组织所有者手动计划任务替代共同排查模式/status确认当前凭证;检查环境变量;看清报错消息里命名的是什么(key?组织访问?),对症清除;管理员层面的限制,找管理员解锁。

博客 1万+

Android AsyncTask 深度解析

params)返回的结果,参数类型由AsyncTask类上的第三个泛型限定;onPreExecute()和onPostExecute()方法都执行在主线程,onProgressUpdate()能够更改UI(更改进度条进度)必然也是主线程。这个小demo通过求1-10的和,在doInBackground()方法中通过延时的方式模拟了耗时操作,简单的演示了AsyncTask的使用。doInBackground()方法执行在线程池某一线程中,(看过源码后得到的结果,通过Log可以知道该方法没有执行在主线程中)

2501_90389522的博客 1582

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

Android 7.0 AsyncTask分析

这一篇博客主要分析一下Android 7.0中AsyncTask的源码。

橡果生长记的博客 2826

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

Android AsyncTask源码解析

最后小编想说:不论以后选择什么方向发展,目前重要的是把Android方面的技术学好,毕竟其实对于程序员来说,要学习的知识内容、技术有太多太多,要想不被环境淘汰就只有不断提升自己,从来都是我们去适应环境,而不是环境来适应我们!这里附上我整理的几十套腾讯、字节跳动,京东,小米,头条、阿里、美团等公司19年的Android面试题。把技术点整理成了视频和PDF(实际上比预期多花了不少精力),包含知识脉络 + 诸多细节。由于篇幅有限,这里以图片的形式给大家展示一小部分。

2401_86353930的博客 2229

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

Android AsyncTask 详解

将复杂工作异步化、线程化对于Android 的性能的提高起到了很重要的作用,Android 框架为开发提供了很多辅助程序,这一篇着重分析Android AsyncTask的原理。

私房菜 6814

基于Android10.0源码深入了解终将老去的AsyncTask

一、前言 相信AsyncTask对每一个开发者来说都非常熟悉,它是一个轻量级的异步任务类。同时,它也经历了很多个版本的调整,如实现上从开始串行执行,再到并行执行,再后来又改回串行执行。AsyncTask从Android API3已经出现,它之所以能够屹立不倒这么多年,想必有很多值得我们学习的地方,本文将基于Android Q(10.0)的源码对AsyncTask进行分析。 二、关于Deprecat...

RyanLee的专栏 1476

基于Android 10.0的AsyncTask最详细的源码分析

 当我们通过线程去执行耗时的任务,并且子执行完之后更新UI时,通常我们采用Handler进行处理,但是如果有很多个任务同时执行时则会显得代码臃肿。Android为我们提供了AsyncTask,它使得异步任务实现起来更加简单,代码更简洁。 public abstract class AsyncTask<Params, Progress, Result> { ... }  AsyncTask是一个抽象的泛型类,它有三个参数Params、Progress、Result。 Params:为参

木小四的博客 1937

Android7.0 AsyncTask机制

在Android中常采用的异步处理机制有Handler和AsyncTask,本文所要介绍的是AsyncTask异步处理机制。   对于每个Android应用程序都运行在一个dalvik虚拟机进程中,应用进程开始的时候会启动一个主线程(MainThread),主线程负责处理和ui相关的事件,因此主线程通常又叫UI线程。而由于Android采用UI单线程模型,所以只能在主线程中对UI元素进行操作。并

宇落 生命不息,奋斗不止...... 2063

安卓的异步任务AsyncTask

第二个泛型用来限制onProgressUpdate(Progress)和publishProgress(Progress)方法传入参数的类型,在publishProgress方法中传入的参数会在onProgressUpdate回调方法中被使用。第一个泛型用来限制execute(Params)和doInBackground(Params)方法传入参数的类型,在execute方法中传入的参数会在doInBackground回调方法中被使用。广泛地讲异步任务就是以多线程的方式完成的功能需求,相对于同步。

weixin_71792169的博客 736

Android AsyncTask 源码解析

一个接着一个的执行,相当于单线程。22行:将我们传入的参数赋值给了mWorker.mParams ,mWorker为一个Callable的子类,且在内部的call()方法中,调用了doInBackground(mParams),然后得到的返回值作为postResult的参数进行执行;看到这里,大家可能会认为,背后原来有一个线程池,且最大支持128的线程并发,加上长度为10的阻塞队列,可能会觉得就是在快速调用138个以内的AsyncTask子类的execute方法不会出现问题,而大于138则会抛出异常。

2401_89790938的博客 991

Android 异步操作AsyncTask

3) 不要手动的调用onPreExecute(), onPostExecute(Result),doInBackground(Params…onPostExecute(Result), 在doInBackground 执行完成后,onPostExecute 方法将被UI thread调用,后台的计算结果将通过该方法传递到UI thread.onPreExecute() ----》doInBackground()------》onPostExecute()基本流程方法都游走一边。

2401_89689665的博客 968

【Android】AsyncTask源码分析

在Android中ui是非线程安全的,更新ui只能在主线程操作,所以我们平时如果遇到子线程更新UI的情况,必须要切换到主线程上之后再执行,Handler消息机制就是一种处理方案,为了更方便的处理异步任务以及更新操作,Android在很早的版本就提供了AsyncTask类供我们处理短耗时的异步任务,方便我们子线程处理耗时任务,主线程更新UI。 AsyncTask其实相当于是Handler和Threa...

风吹起如花般细碎流年 464

一文详解 Android asynctask使用方式(一)

AsyncTask在各版本中源码的实现方式不用,但有时我们又需要用到AsyncTask,那我们该怎么使用它呢?

bjxiaxueliang的CODING小栈 840

安卓 AsyncTask 异步任务

安卓异步任务实验代码(未修改)xmljava 实验代码(未修改) xml <?xml version="1.0" encoding="utf-8"?> <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res-auto" x

Sun_XiaoChuan的博客 1793
上一篇: 说说AsyncTask演化历程里的小纠结
下一篇: 说说Pluma插件管理框架
悠然红茶
博客等级 码龄26年 270粉丝 27原创
评论 10
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

悠然红茶

原来还有打赏功能,试一下呦。

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值