说说AsyncTask演化历程里的小纠结

基于javaEE的图书管理系统 极简的图书管理系统,无任何样式修饰,适合新手练手(图文并释) 1、实现了用户注册、登录,图书的添加、修改、删除和修改操作 2、工具需要:eclipse、mysql、Tomcat 3、做系统之前在eclipse需要配置Tomcat服务器和导入mysql连接数据库的jar包 4、数据库中建一个user表存用户信息,一个book表存图书信息 一、各种页面 index.html文件,系统运行的首页,有登录... 阅读详情

      笔者以前写过一篇文章《AsyncTask研究》,阐述了android框架中AsyncTask的实现原理。当时是基于Android 7.0的代码来分析的,后来就没有再跟进AsyncTask的变化了。最近基于Android 10的代码,又看了一下AsyncTask,发现其实现变动了一点点,那么我们不妨重新串一下这几年不同Android版本里AsyncTask的变动,看看会有什么有趣的东西。

    当然,AsyncTask的基本原理是没什么本质变化的,大家如有兴趣,可自行参考《AsyncTask研究》一文,本文不打算全部重述一遍。不过有一张示意图倒是可以拿来供大家复习一下:

    另一个要复习的概念是线程池执行器ThreadPoolExecutor。这个类的构造函数如下:

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

    corePoolSize指明了线程池的基本大小,如果线程池里当前存在的线程数小于corePoolSize,那么添加任务时,线程池就会创建新线程来干活。而如果线程数达到了corePoolSize,那么任务会先缓存进workQueue,直到塞满workQueue。塞满队列后,如果还有新的工作添加进来,线程池就会超额创建新线程来干活。当然,超额也是有限度的,最多能达到maximumPoolSize个线程。而如果在队列已满且线程数也到达最大阀值后,还继续添加新工作,那么线程池就会依照某个拒绝策略进行拒绝了。上面构造函数里最后一个参数,就体现了拒绝策略。

    为了更有效地运用线程,线程池还设定了两个关于时间的控制量,一个是keepAliveTime,另一个是allowCoreThreadTimeOut。简单地说,如果线程池里的线程的空闲时长达到keepAliveTime阀值时,线程池就会让超时的线程退出,直到线程数量降到corePoolSize大小为止,此时一般不会再轻易退出线程了,除非allowCoreThreadTimeOut的值为true,这个值明确告诉线程池,即便线程数小于corePoolSize了,也会一直把空闲线程退出去,直到线程数量为0。注意,线程的空闲时长是指做完当前任务后,等待新任务被分配给它的那段时长,不是任务执行过程中sleep的时长。

    线程池的那些关键参数一般都可在运行期动态设置,常见的设置函数有:

  • void setCorePoolSize(int corePoolSize)
  • void setKeepAliveTime(long time, TimeUnit unit)
  • void setMaximumPoolSize(int maximumPoolSize)
  • void setRejectedExecutionHandler(RejectedExecutionHandler handler)
  • void setThreadFactory(ThreadFactory threadFactory)

    现在我们可以绘制一张线程池的示意图:


1. on Android 2.3

    复习完以上这些知识,我们就可以着手看AsyncTask的变动历史了。我们先看Android2.3上的线程池:
【AsyncTask.java on Android2.3】

private static final int CORE_POOL_SIZE = 5;
private static final int MAXIMUM_POOL_SIZE = 128;
private static final int KEEP_ALIVE = 1;

private static final BlockingQueue<Runnable> sWorkQueue = new LinkedBlockingQueue<Runnable>(10);
. . . . . .
private static final ThreadPoolExecutor sExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE, 
                          MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, 
                          sWorkQueue, sThreadFactory);

也就是说,尝试形成一个核心池大小为5的线程池。如果有5个任务尚在执行时,又来了第6个任务,则新任务会缓存进sWorkQueue队列,不过这个队列其实也不怎么大,最多能缓存10个任务。在队列塞满之后,如果还有新任务到来,则开始创建新线程来做事,而且最多再创建123(即128-5)个线程。于是,在极端情况下线程池会是下图这个样,怎么看都觉得线程数挺壮观了:

2. on Android 4.4

    到了Android 4.4,Google的工程师似乎发现,用户在使用AsyncTask时,大多数情况下是希望那些被添加的任务能够一个个串行执行的,只有较少的情况是希望多线程并行执行的。所以,新AsyncTask里的默认执行器在声明时就写为“串行执行器”了。

private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

但是,早期Android版本里AsyncTask已经写成多线程并行执行的鬼样子了,这总得兼顾一下嘛。于是,AsyncTask内部搞了两个静态的执行器,分别表示成AsyncTask.THREAD_POOL_EXECUTOR 和刚刚看到的 AsyncTask.SERIAL_EXECUTOR,前者是可并行执行的执行器,后者是串行执行的执行器。这个在《AsyncTask研究》一文中已有阐述。

    串行执行时,示意图如下:

串行时其实最终也会用到线程池,只是这个线程池已经退化到只有一个线程在干活了。

    并行执行时,AsyncTask也稍微变化了一点儿。估计是为了改变以前那种线程满天飞的壮观场面,同时又考虑到多核CPU已经比较普遍,于是开始让AsyncTask在不过度产生线程的情况下,充分利用一下多核,所以AsyncTask里线程池的相关代码变成了这样:
【AsyncTask.java on Android4.4】

private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
private static final int KEEP_ALIVE = 1;
. . . . . .
. . . . . .
private static final BlockingQueue<Runnable> sPoolWorkQueue =
        new LinkedBlockingQueue<Runnable>(128);

public static final Executor THREAD_POOL_EXECUTOR
        = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
                TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

可以看到,会先调用availableProcessors()获取虚拟机当前可用的处理器数量。再基于这个数量计算Core Pool和线程池最大的线程数。比如CPU数为2时,满负荷时的线程池示意图如下:

看到了吧,最多才会有5个线程在同时干活。也就是说,线程有点儿贵,要谨慎地给。

    但是,设计师很明显不希望普通用户能设定AsyncTask的默认行为,所以setDefaultExecutor()成员函数被注解为@hide,就是不让别人用嘛。

/** @hide */
public static void setDefaultExecutor(Executor exec) {
    sDefaultExecutor = exec;
}

这个函数主要在ActivityThread里调用了一下,做了一点兼容性处理:

if (data.appInfo.targetSdkVersion <= android.os.Build.VERSION_CODES.HONEYCOMB_MR1) {
    AsyncTask.setDefaultExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
}

可以看到,如果所运行的App是那种针对旧系统(Android 3.1(HONEYCOMB MR1)之前的系统)的应用,则把运行该应用的进程里的AsyncTask的默认行为设为“按多线程并行执行”,而如果运行的是针对新系统的应用,则AsyncTask的默认行为统统按串行执行。

    当然,上面只是修改了默认行为,如果某个新版应用明确要求其AsyncTask按多线程并行处理,它可以直接调用executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR)。

3. on Android 7.0

    待到发展到Android 7.0,在并行执行时,又变化了一点儿。仍然会先调用availableProcessors()获取虚拟机当前可用的处理器数量,然而CORE_POOL_SIZE不再只是简单地按CPU_COUNT + 1来计算啦,这可能是因为发现在极端情况下,把所有的CPU都占上有点儿太狠了,这肯定会影响到其他后台线程的调度。新的CORE_POOL_SIZE被控制在2到4之间,说明在占用资源方面下手的确轻了少许。相关的代码截选如下:
【AsyncTask.java on Android7.0】

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 = 30;
. . . . . .
. . . . . .
private static final BlockingQueue<Runnable> sPoolWorkQueue =
        new LinkedBlockingQueue<Runnable>(128);


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);
    threadPoolExecutor.allowCoreThreadTimeOut(true);
    THREAD_POOL_EXECUTOR = threadPoolExecutor;
}

    串行执行的情况没什么变化,我们就不赘述了。我们还以CPU数为2为例,并行执行的示意图如下:

    另外,在Android 7上,AsyncTask线程池对线程的空闲时长也更加容忍了。以前空闲1秒钟,就会终止线程,现在最多允许空闲30秒。这是为了保证不会出现频繁快速地终止、创建线程。而且,线程池执行器还调用了allowCoreThreadTimeOut(true),也就是说,如果空闲时间过长,连CorePool里的线程也可以终止。

4. on Android 8.0

    Android 8.0上的AsyncTask和Android 7.0的差不多,在线程池的调度方面没什么变化。只是在创建AsyncTask时,做了点小手脚。从代码上看,AsyncTask多了两个隐藏(@hide)的构造函数:

  • public AsyncTask(@Nullable Handler handler)
  • public AsyncTask(@Nullable Looper callbackLooper)

    也就是说,在系统内部可以指定一个looper,处理AsyncTask的MESSAGE_POST_RESULT和MESSAGE_POST_PROGRESS。

public AsyncTask(@Nullable Looper callbackLooper) {
    mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
        ? getMainHandler()
        : new Handler(callbackLooper);

如果looper是UI线程里的looper,这两个事件由getMainHandler()返回的InternalHandler处理,而如果是其他线程的looper,那么就是用一个最普通的Handler来处理,相当于什么事都不做。这难道不让人困惑吗?

5. on Android 10.0

    Android 9上的AsyncTask和Android 8的完全一样,所以我们直接看Android 10上的AsyncTask。在Android 10上:
1)主线程池的队列从LinkedBlockQueue改成了SynchronousQueue;
2)主线程池的CorePool大小改成了1;
3)明确设定了新的拒绝策略sRunOnSerialPolicy;

private static final int CORE_POOL_SIZE = 1;
private static final int MAXIMUM_POOL_SIZE = 20;
private static final int BACKUP_POOL_SIZE = 5;
private static final int KEEP_ALIVE_SECONDS = 3;
. . . . . .
. . . . . .
public static final Executor THREAD_POOL_EXECUTOR;

static {
    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
            CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
            new SynchronousQueue<Runnable>(), sThreadFactory);
    threadPoolExecutor.setRejectedExecutionHandler(sRunOnSerialPolicy);
    THREAD_POOL_EXECUTOR = threadPoolExecutor;
}

    以前使用LinkedBlockQueue的情况,我们已经了解了,此处不再赘述。现在改成SynchronousQueue后,线程池的行为会有什么不同吗?我们可以这样理解,SynchronousQueue的内部是没有任务缓存队列的,所以当CorePool线程用完后,其实是立即起新线程来做事的,直到线程数达到MAXIMUM_POOL_SIZE。这就不像以前那样,还有个填充任务队列的过程。在线程数达到MAXIMUM_POOL_SIZE之后,如果还有新任务,则会按拒绝策略处理。

    Android 10上没有采用ThreadPoolExecutor已有的拒绝策略,而是专门设计了一个自定义的拒绝策略:

private static ThreadPoolExecutor sBackupExecutor;
private static LinkedBlockingQueue<Runnable> sBackupExecutorQueue;

private static final RejectedExecutionHandler sRunOnSerialPolicy =
        new RejectedExecutionHandler() {
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        android.util.Log.w(LOG_TAG, "Exceeded ThreadPoolExecutor pool size");

        synchronized (this) {
            if (sBackupExecutor == null) {
                sBackupExecutorQueue = new LinkedBlockingQueue<Runnable>();
                sBackupExecutor = new ThreadPoolExecutor(
                        BACKUP_POOL_SIZE, BACKUP_POOL_SIZE, KEEP_ALIVE_SECONDS,
                        TimeUnit.SECONDS, sBackupExecutorQueue, sThreadFactory);
                sBackupExecutor.allowCoreThreadTimeOut(true);
            }
        }
        sBackupExecutor.execute(r);
    }
};

看到了吗,在拒绝策略中又用到了一个备用的线程池,线程池的Core Pool大小和最大线程数都是5(BACKUP_POOL_SIZE),也就是说,当拒绝策略处理任务时,最多还可再启动5个线程来干活,如果仍然不够用的话,新任务就会记录进一个几乎无限大的LinkedBlockingQueue。示意图如下:


6. 小结

    经过本文的阐述,大家是不是能感到维护AsyncTask的工程师的一点小纠结呢?一开始希望做事的线程多一点,后来发现太多了,要按CPU数限制一下。一开始在主线程池里用LinkedBlockingQueue来缓存任务,后来干脆把LinkedBlockingQueue移到了拒绝策略里。大家是不是也觉得挺有趣?

解密Whisper模型与Speaker Diarization的结合 本文介绍了如何将Whisper语音识别模型与Speaker Diarization(说话人分割)技术相结合,实现多人对话场景下的语音转录和说话人识别。文章详细讲解了技术背景、环境配置和代码实现方法,通过Pyannote进行说话人分割,结合Whisper进行语音转文本,最终输出包含说话人信息的完整转录结果。该解决方案适用于会议记录、访谈分析等场景,显著提升了语音处理的应用价值。 阅读详情

相关推荐

幸狐RV1106开发板实战:5分钟搞定Yolo8模型部署(附避坑指南)

本文详细介绍了在幸狐RV1106开发板上快速部署YOLOv8模型的实战流程。通过RKNN-Toolkit2工具链,将ONNX模型转换为RV1106 NPU专用的RKNN格式,并完成交叉编译与上板运行。文章重点分享了环境搭建、模型转换的关键步骤以及常见的避坑指南,帮助开发者高效实现边缘AI目标检测应用。

weixin_28677451的博客 918

Android多线程-AsyncTask工作流程(源码)

AsyncTask的源码是很简单的,看着并不复杂。只是对Handler和ThreadPoolExecutor进行了一下封装。基于api25(7.1)的代码,使用起来也是很简单的,看上个就知道了。一般要继承AsyncTask并重写下面几个方法,这些方法的执行顺序一目了然:原文地址 //任务执行前调用 protected void onPreExecute() {} //执行后台任务 protected

喵了个呜的博客 988

深空探测处理软件USGS-ISIS的下载安装

深空探测处理软件USGS-ISIS下载安装教程

qq_31721595的博客 3313

源码解析-AsyncTask sDefaultExecutor解析

上篇博文我們一起查看了AsyncTask的执行流程,但是由于篇幅的原因,我们没有对AsyncTask的默认启动方式(sDefaultExecutor)进行解析。那么,这篇博文我们对sDefaultExecutor进行解析。 相关博文 Android基础-AsyncTask基本使用 源码解析-AsyncTask源码解析 我们先回顾一下在上篇博文中的内容,再启动AsyncTask的时候我...

just_hu的博客 820

CHARLS数据库下载避坑指南:从注册到数据获取的完整流程(2023最新版)

本文提供2023年最新版CHARLS数据库下载与使用全流程指南,涵盖从注册、数据申请到清洗的高效实践。重点解析邮箱选择、协议签署等关键步骤,并分享多线程下载、格式转换等实用技巧,助力研究者快速获取并处理这一中国中老年健康研究的黄金标准数据。

red88的博客 930

避坑指南:CentOS7.9安装Python3.8.16后yum报错的快速修复方法

本文详细解析了在CentOS7.9系统安装Python3.8.16后导致yum报错的原因,并提供了快速修复方法。通过修改yum配置文件指向Python2解释器,以及使用alternatives工具管理多版本Python,有效解决兼容性问题。同时推荐使用虚拟环境隔离开发环境,避免影响系统稳定性。

weixin_26908317的博客 498

Java线程池类ThreadPoolExecutor、ScheduledThreadPoolExecutor及Executors工厂类

Java中的线程池类有两个,分别是:ThreadPoolExecutor和ScheduledThreadPoolExecutor,这两个类都继承自ExecutorService。利用这两个类,可以创建各种不同的Java线程池,为了方便我们创建线程池,Java API提供了Executors工厂类来帮助我们创建各种各样的线程池。下面我们分别介绍一下这三个类。Java线程池ExecutorService

huang211630的专栏 478

手把手教你学 MATLAB 实战训练(6.5):基础实战实例

MATLAB 是一款强大的数学软件,广泛应用于工程计算、信号处理、控制系统设计、图像处理等领域。学习 MATLAB 不仅可以提高你的编程技能,还能帮助你解决实际的数学和工程问题。下面我将通过几个实战训练实例来教你如何使用 MATLAB。

xiaoheshang_123的博客 369

安卓复习---AsyncTask的使用和源码分析以及优缺点分析

参考:https://www.jianshu.com/p/ee1342fcf5e7 https://www.cnblogs.com/dirt2/p/10473457.html https://www.cnblogs.com/yanyojun/p/6414919.html https://blog.csdn.net/weixin_43507738/article/details/83418989 AsyncTask作为官方封装好的轻量级处理异步任务的抽象类,AsyncTask内部封装好Handler和

u014436704的专栏 352

Ubuntu零基础教学-如何把Ubuntu20.04界面从英文修改为中文?| 超级详细,建议收藏

带你如何把Ubuntu20.04界面从英文修改为中文?| 超级详细,建议收藏

**My Coding Family** 5340

Pointnet++环境配置(Windows11和ubuntu)及训练教程

PS:前两行命令是数据处理的命令,主要是进行数据读取和生成相应的训练数据格式,在Ubuntu上是正常运行的,在Windows上运行会失败,无法生成训练用的数据格式,所以最好在Ubuntu上训练,如果一定要用Windows,可以ubuntu上生成数据格式在导到Windows上,数据生成不需要安装torch。通过anaconda配置的环境,在官网找的命令安装的,版本是2.1.0+cu118。训练命令:我使用的pycharm,直接在pycharm中打开终端,运行命令。Python版本:3.7。

AIcurator的博客 2558

论AsyncTask线程与Runnable接口线程的区别,及二者的使用方法(含demo)

事先表述一下:在做过一次嵌入式实验之后,发现安卓有一个轻量级异步类AsyncTask线程。AsyncTask每产生一个线程需要使用execute()或者executeOnExecuter()方法。其中execute()方式是产生串行线程,executeOnExecuter()方法产生并行线程。由于是轻量级类线程,封装了线程池,AsyncTask并不能无限的产生子线程,它所产生的线程并行最大数取决于...

宇某的博客 1452

最新Python爬虫实战(入门爬虫篇)——案例15:微博热搜数据采集(详细爬虫思路截图+抓包动图演示+完整爬虫代码+详细注释)

本次案例通过 Python 爬虫技术,成功实现了对微博热搜 API 接口数据的批量爬取与 Excel 保存。代码采用模块化设计,包含接口请求、JSON 解析、数据提取、Excel 持久化等完整流程;通过模拟真实浏览器的请求头和 cookies,有效规避基础反爬策略,保证请求的稳定性。整个爬虫逻辑遵循“API请求 → JSON解析 → 数据提取 → 保存到Excel”的标准流程,与异步加载类网站的爬取范式高度一致。AJAX 接口抓包与分析。

努力让自己发光,对的人才能迎着光而来 7万+

spring-petclinic-rest的15个API端点全解:Swagger UI与OpenAPI文档实战速查清单

**spring-petclinic-rest** 是一个基于 Spring Boot 的纯 REST API 示例项目,把宠物诊所的完整业务——**owners(主人)、pets(宠物)、vets(兽医)、visits(就诊记录)、pettypes(宠物类型)、specialties(专科)和 users(用户)**——全部以标准 RESTful 端点对外提供,没有任何网页界面。项目内建 **S

gitblog_00689的博客 444

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

expo-calendar 版本演进全解析:从 Changelog 读懂 Expo 日历模块的重构、权限模型与平台化修复

> 阅读本文,你将沿着 `packages/expo-calendar/CHANGELOG.md` 的版本轨迹,系统理解 Expo 官方日历模块 expo-calendar 在 Expo 仓库中的两次 API 大换代(Legacy → Calendar@Next)、iOS/Android 原生层迁移(Expo Modules API、Kotlin/协程)、权限模型演进,以及数十个带有明确根因的跨平

gitblog_00907的博客 820

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

ThreadPoolExecutor中活跃的线程数超过corePoolSize后新来的请求会进入阻塞队列

关于该类的文档 https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ThreadPoolExecutor.html 描述中有以下内容 Core and maximum pool sizes ............. When a new task is submitted in method execute(jav...

xdx54321的博客 1万+

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

Android实战技巧:深入解析AsyncTask

AsyncTask的介绍及基本使用方法 关于AsyncTask的介绍和基本使用方法可以参考官方文档和Android实战技巧:多线程AsyncTask这里就不重复。 AsyncTask引发的一个问题 上周遇到了一个极其诡异的问题,一个小功能从网络上下载一个图片,然后放到ImageView中,是用AsyncTask来实现的,本身逻辑也很简单,仅是在doInBackground中用HTTP请求把图

稀有猿诉 10万+

android学习视频!2021Android大厂面试知识分享,内含福利

开头 25岁那年,我从京东离职,入职百度。 在百度认识了当时的架构师久哥(T9级别),因为他的一番话,彻底改变了我的职业生涯,短短三年的时间,我从一枚普通程序员成长为别人眼中的技术大咖。 当时因为业务需要,也承蒙久哥照顾,他跟我说过这样一段话: 他问,“如果用5年的时间学习数据库,你能不能成为这个领域的专家?” 我说,“应该可以吧” 他说,“你现在25,5年后也才30,30岁就能成为某个领域的专家,为什么不去做呢?你看看周围有多少30岁的人还一事无成,而那个时候的你已经是数据库专家了。” 当时的我,刚刚

m0_52308677的博客 561

AsyncTask分析笔记

AsyncTask. execute(Params… params) params这个参数就是入参。异步执行任务的时候需要用到的参数可以用这个params传入。在这个方法可以接受到传入的参数。protected String doInBackground(Params… params) 这个execute(Params… params)方法的源码:里面去调用一个executeOnExecutor(...

qq_40207976的博客 203

Android AsyncTask 分析内部实现

sdk3.0前,使用内部的线程池,多线程并发执行。线程池大小等于5,最大达128 sdk3.0后,使用默认的serial线程池,执行完一个线程,再顺序执行下一个线程。sdk4.3时 线程池大小等于5,最大达128 sdk4.4后线程池大小等于 cpu count + 1,最大值为cpu count * 2 + 1 sdk3.0后有两种线程池的实现,默认为 Serial 线程池 public

打渔还是晒网 —— stone 3944

spring-boot @Async 的使用、自定义Executor的配置方法

简单几步,实现异步新线程调用。

Clement-Xu的专栏 3万+

Android 7.0 AsyncTask分析

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

橡果生长记的博客 2826

AsyncTask 使用须知

AsyncTask 是从Android 1.5(Api Level 3)中引入的, 在1.5发布的年代,为了在1.5之前的版本中使用AsyncTask, 都是把AsyncTask 源代码复制到项目中使用的。 现在市场上低于1.5版本的Android手机几乎都销声匿迹了,所以也开始使用系统的AsyncTask了。 但是Android系统的AsyncTask 在执行顺序上,每个版本是有些变化的。 ...

weixin_30709929的博客 143

AsyncTask 各版本的不同

各版本不同: 1.5 AsyncTask.execute() 添加的任务进入单线程队列。 1.6到3.0之前 AsyncTask.execute() 添加的任务进入多线程池。同时线程数为5-128。   3.0之后 AsyncTask.execute() 根据设备系统判断: 3.0之前进度多线程池,3.0之后进度单线程队列。 同时还多了一个方法AsyncTask.exec

代小宁 1172

【Java 并发编程】Java 创建线程池的正确姿势: Executors 和 ThreadPoolExecutor 详解...

这种情况下,一旦提交的线程数超过当前可用线程数时,就会抛出java.util.concurrent.RejectedExecutionException,这是因为当前线程池使用的队列是有边界队列,队列已经满了便无法继续处理新的请求。其实,在上面的报错信息中,我们是可以看出蛛丝马迹的,在以上的代码中其实已经说了,真正的导致OOM的其实是LinkedBlockingQueue.offer方法。Executors的创建线程池的方法,创建出来的线程池都实现了ExecutorService接口。

AI天才研究院 1万+

ThreadPoolExecutor线程池核心参数详解

理解ThreadPoolExecutor线程池的corePoolSize、maximumPoolSize和poolSize 我们知道,受限于硬件、内存和性能,我们不可能无限制的创建任意数量的线程,因为每一台机器允许的最大线程是一个有界值。也就是说ThreadPoolExecutor管理的线程数量是有界的。线程池就是用这些有限个数的线程,去执行提交的任务。然而对于多用户、高并发的应用来说,提交的任...

大隐隐于野 3万+
上一篇: 轻松一把,写个《扫雷》来玩玩(以wxPython实现)
下一篇: AsyncTask研究(以Android 10.0为准)
悠然红茶
博客等级 码龄26年 270粉丝 27原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

悠然红茶

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

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

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

打赏作者

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

抵扣说明:

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

余额充值