2024年Android最全聊聊Android线程优化这件事，华为大神花费5个月打造的这份714页学习笔记系列

原创 于 2024-05-14 05:58:37 发布 · 1k 阅读 · 21 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#android #面试 #学习

最后

目前已经更新的部分资料：



网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

  1. 设置降级开关，方便线上有问题时，及时对单个SDK进行降级处理。
3.2.1 行业方案

（1）反射收敛，但是使用反射来收敛线程池的确有一些潜在的弊端：

  • 性能开销：反射在执行时需要进行一系列的检查和解析，这会比直接的Java方法方法调用带来更大的性能开销。
  • 安全问题：反射可以访问所有的字段和方法，包括私有有的和受保护的，这可能会破坏对象的封装性，导致安全问题。
  • 代码复杂性：使用反射的代码通常比直接的Java代码更复杂，更难理解和维护。

因此，虽然反射是一种强大的工具，但在使用时需要谨慎，尽量避免不必要的使用。

（2）代理收敛，但是使用代理设计模式来收敛线程池也有一些潜在的弊端：

  • 增加复杂性：代理方式会引入额外的类和对象，这会增加系统的复杂性。对于简单的问题，使用代理可能会显得过于复杂。
  • 代码可读性：由于代理方式涉及到额外的抽象层，这可能会对代码的可读性产生一定的影响。
  • 调试困难：由于代理模式的存在，错误可能会被掩盖或者难以定位，这可能会使得调试变得更加困难。

因此，虽然代理模式是一种强大的设计模式，但在使用时也需要考虑到这些潜在的问题。

（3）协程收敛，但是使用协程收敛线程池也有一些局限性和潜在的弊端：

  • 需要依赖Kotlin协程库：使用Kotlin协程需要依赖Kotlin协程库，如果应用程序中没有使用Kotlin语言，那么需要额外引入Kotlin库，增加了应用程序的体积。
  • 协程的执行时间不能过长：Kotlin协程的执行时间不能过长，否则会影响其他协程的执行。因此，在使用Kotlin协程进行线程收敛时，需要合理控制协程的执行时间。
  • 可能会导致内存泄漏：如果协程没有正确地取消，可能会导致内存泄漏。因此，在使用Kotlin协程时，需要注意正确地取消协程。

因此，虽然Kotlin协程可以通过使用协程调度器来实现线程收敛，但是也存在一些弊端，需要开发者根据具体情况来选择是否使用。

（4）插桩收敛，虽然插桩也有一些不足之处：

  • 可能影响程序行为：如果插桩代码改变了程序的状态或者影响了线程的线程的调度，那么它可能会改变程序的行为。
  • 可能引入错误：如果插桩代码桩代码本身存在错误，那么它可能会引入新的错误到程序中。

但是这些缺点在线程池收敛的时候还是可控的，相比于上面的反射收敛、代理收敛和协程收敛来说，还有许多优点：

  • 直接性：插桩直接在代码中插入额外的逻辑，不需要通过代理或反射射间接地操作对象，这使得插桩更直接，更易于理解和控制。
  • 灵活活性：插桩可以在任何位置插入代码，，这提供了很大的灵活性。而代理和反射通常只能操作公开的接口和方法。
  • 无需修改原始代码：插桩通常常不需要常不需要修改原始的线程池代码，这使得它可以在不影响原始代码的情况下收集信息。
  • 颗粒度控制：可以对某个方法或某段代码进行线程收敛，而不是整个应用程序。

综上所述，我就选择了更加通用、灵活、精确的方式来收敛二方和三方的线程池—插桩代理。

3.2.2 代码设计图

3.2.3 代码流程图

暂时无法在飞书文档外展示此内容

3.2.4 代码实施
  1. 创建NewThreadTrackerPlugin，在插件里主要是获取到需要进行代理的线程池白名单以及注册ThreadTrackerTransform。
class NewThreadTrackerPlugin implements Plugin<Project> {

    @Override
    void apply(Project project) {
        System.out.println("ThreadTracker:start ThreadTrackerPlugin")
        project.getRootProject().getSubprojects().each { subProject ->
            PluginUtils.addProjectName(subProject.name)
            PluginUtils.projectPathList.add(subProject.projectDir.toString())
        }
        org.gradle.api.plugins.ExtraPropertiesExtension ext = project.getRootProject().getExtensions().getExtraProperties()
        //通过配置来设置是否需要输出所有创建线程池的txt文件，文件名为"thread_tracker_XXX.txt"
        if (ext.has("scanProject")) {
            boolean scan = ext.get("scanProject")
            PluginUtils.setScanProject(scan)
            System.out.println("ThreadTracker:需要扫描项目吗？" + scan)
        }
        //通过配置来获取需要进行插桩代理的白名单
        if(ext.has("whiteList")){
            List<String> list = ext.get("whiteList")
            PluginUtils.addWhiteList(list)
        }else {
            System.out.println("ThreadTracker:请创建thread_tracker.gradle文件，设置whiteList白名单")
        }
        //注册ThreadTrackerTransform。
        //Gradle Transform 是 Android 官方提供给开发者在项目构建阶段，即由 .class 到 .dex 转换期间修改 .class 文件的一套 API。目前比较经典的应用是字节码插桩、代码注入技术。
        AppExtension appExtension = (AppExtension) project.getProperties().get("android")
        appExtension.registerTransform(new ThreadTrackerTransform(), Collections.EMPTY_LIST)
    }

}
  1. 创建 ThreadTrackerTransform，重写ThreadTrackerTransform的transform方法，在该方法里面来遍历文件目录下和Jar包中的class文件，并让ClassReader接受的是我们自定义的ThreadTrackerClassVisitor。
/**
 * transform 方法来处理中间转换过程，主要逻辑在该方法中实现。我们可以在 transform 方法中，实现对字节码的修改、处理等操作。
 * @param transformInvocation
 */
@Override
void transform(@NonNull TransformInvocation transformInvocation) {
    ...
    //对于一个.class文件进行Class Transformation操作，整体思路是这样的：
                // ClassReader --> ClassVisitor(1) --> ... --> ClassVisitor(N) --> ClassWriter
                ClassReader classReader = new ClassReader(file.bytes)
                ClassWriter classWriter = new ClassWriter(classReader, ClassWriter.COMPUTE_MAXS)
                ClassVisitor cv = new ThreadTrackerClassVisitor(classWriter, null)
                classReader.accept(cv, EXPAND_FRAMES)
                byte[] code = classWriter.toByteArray()
                FileOutputStream fos = new FileOutputStream(
                        file.parentFile.absolutePath + File.separator + name)
                fos.write(code)
                fos.close()
    ...
}
  1. 创建ThreadTrackerClassVisitor，重写visitMethod来返回自定义的MethodVisitor，通过这个对象来访问方法的详细信息。

在visitMethod方法方法中，我们可以插入自己的代码，以修改或替换原有的方法声明声明。例如，我们可以改变方法的访问权限、改变方法的参数、改变方法的返回值，甚至可以完全替换原有的方法声明。

@Override
public MethodVisitor visitMethod(int access0, String name0, String desc0, String signature0, String[] exceptions) {
    MethodVisitor mv = cv.visitMethod(access0, name0, desc0, signature0, exceptions);
    if (filterClass(className)) {
        return mv;
    }
    return new ProxyThreadPoolMethodVisitor(ASM6, mv, className);
}

/**
*。 过滤掉不需要插桩的类，比如这个插桩代码模块、自定义的线程池等等
**/
private boolean filterClass(String className) {
    return className.contains("com/lalamove/threadtracker/") || className.contains("com/lalamove/plugins/thread") || className.contains("com/tencent/tinker/loader") || className.contains("com/lalamove/huolala/client/asm/HllPrivacyManager");
}
  1. 创建ProxyThreadPoolMethodVisitor，并重写它的visitMethodInsn方法来真实插桩自己的线程池。

在visitMethodInsn方法中，我们可以插入自己的代码，以修改或替换原有的方法调用。

  @Override
    public void visitMethodInsn(int opcode, String owner, String name, String descriptor, boolean isInterface) {
        //如果配置中是需要扫描App，则把创建线程池的类名全部都写在"thread_tracker_XXX.txt"里面，供开发者统计、分类、设置白名单和降级处理
        if (PluginUtils.getScanProject()) {
            if (owner.equals(O_ThreadPoolExecutor) && name.equalsIgnoreCase("<init>")) {
                PluginUtils.writeClassNameToFile("创建ThreadPoolExecutor的类：" + className);
            } 
        }
        //如果配置中是需要插桩代理线程池，则把原本的类 "java/util/concurrent/ThreadPoolExecutor"换成了我们自定义的类"com/lalamove/threadtracker/proxy/BaseProxyThreadPoolExecutor"
        //mClassProxy只是一个总开关，是否开启代理；具体某个类是否需要代理，在创建线程池的具体地方会根据类名来判断
        if (mClassProxy) {
        if (owner.equals(O_ThreadPoolExecutor) && name.equalsIgnoreCase("<init>")) {
                if ("(IIJLjava/util/concurrent/TimeUnit;Ljava/util/concurrent/BlockingQueue;)V".equalsIgnoreCase(descriptor)) {
                    mv.visitLdcInsn(className);
                    mv.visitMethodInsn(opcode, O_BaseProxyThreadPoolExecutor, name, "(IIJLjava/util/concurrent/TimeUnit;Ljava/util/concurrent/BlockingQueue;Ljava/lang/String;)V", false);
                } else if ("(IIJLjava/util/concurrent/TimeUnit;Ljava/util/concurrent/BlockingQueue;Ljava/util/concurrent/ThreadFactory;)V".equalsIgnoreCase(descriptor)) {
                    mv.visitLdcInsn(className);
                    mv.visitMethodInsn(opcode, O_BaseProxyThreadPoolExecutor, name, "(IIJLjava/util/concurrent/TimeUnit;Ljava/util/concurrent/BlockingQueue;Ljava/util/concurrent/ThreadFactory;Ljava/lang/String;)V", false);
                } else if ("(IIJLjava/util/concurrent/TimeUnit;Ljava/util/concurrent/BlockingQueue;Ljava/util/concurrent/RejectedExecutionHandler;)V".equalsIgnoreCase(descriptor)) {
                    mv.visitLdcInsn(className);
                    mv.visitMethodInsn(opcode, O_BaseProxyThreadPoolExecutor, name, "(IIJLjava/util/concurrent/TimeUnit;Ljava/util/concurrent/BlockingQueue;Ljava/util/concurrent/RejectedExecutionHandler;Ljava/lang/String;)V", false);
                } else if ("(IIJLjava/util/concurrent/TimeUnit;Ljava/util/concurrent/BlockingQueue;Ljava/util/concurrent/ThreadFactory;Ljava/util/concurrent/RejectedExecutionHandler;)V".equalsIgnoreCase(descriptor)) {
                    mv.visitLdcInsn(className);
                    mv.visitMethodInsn(opcode, O_BaseProxyThreadPoolExecutor, name, "(IIJLjava/util/concurrent/TimeUnit;Ljava/util/concurrent/BlockingQueue;Ljava/util/concurrent/ThreadFactory;Ljava/util/concurrent/RejectedExecutionHandler;Ljava/lang/String;)V", false);
                } else {
                    mv.visitMethodInsn(opcode, O_BaseProxyThreadPoolExecutor, name, descriptor, false);
                }
                return;
            } 
        }
        super.visitMethodInsn(opcode, owner, name, descriptor, isInterface);
    }

上述使用到的一些常量定义如下，也引入到了我们自己自定义的线程池。

class ClassConstant {
    //Java里面创建线程池的类名
    static final String O_ThreadPoolExecutor = "java/util/concurrent/ThreadPoolExecutor";
   
    //自定义创建线程池的类名
    static final String O_BaseProxyThreadPoolExecutor = "com/lalamove/threadtracker/proxy/BaseProxyThreadPoolExecutor";
  
}
  1. 创建BaseProxyThreadPoolExecutor，重写了创建线程池的所有构造方法，也通过传入的类名判断了该类里面的线程池是否需要代理，以及代理的是的CPU密集型线程池还是IO密集型线程池。
package com.lalamove.threadtracker.proxy

import android.util.Log

import com.lalamove.threadtracker.TrackerUtils
import java.util.concurrent.*

/**
 * ThreadPoolExecutor代理类
 */
open class BaseProxyThreadPoolExecutor : ThreadPoolExecutor {

    var mProxy = true

    //App层自定义的IO线程池
    private var threadPoolExecutor: ThreadPoolExecutor =
        TrackerUtils.getProxyNetThreadPool()

    constructor(
        corePoolSize: Int,
        maximumPoolSize: Int,
        keepAliveTime: Long,
        unit: TimeUnit?,
        workQueue: BlockingQueue<Runnable>?,
        className: String?,
    ) : super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue) {
        init(corePoolSize,
            maximumPoolSize,
            keepAliveTime, className)
    }

    private fun init(
        corePoolSize: Int,
        maximumPoolSize: Int,
        keepAliveTime: Long,
        className: String?,
    ) {
        //判断className下创建的线程池是否要被插桩代理
        if (className != null) {
            mProxy = TrackerUtils.isProxy(className)
        }
        //单线程暂不代理
        if (corePoolSize == 1 || (corePoolSize == 0 && maximumPoolSize == 1)) {
            mProxy = false
        }
        if (!mProxy) {
            return
        }
        //设置核心线程超时允许销毁
        if (keepAliveTime <= 0) {
            setKeepAliveTime(10L, TimeUnit.MILLISECONDS)
        }
        allowCoreThreadTimeOut(true)
        //设置className的线程池被代理为CPU线程池
        if (className != null && TrackerUtils.proxyCpuClass(className)) {
            threadPoolExecutor = TrackerUtils.getProxyCpuThreadPool()
        }
    }

    ...
   
    override fun submit(task: Runnable): Future<*> {
        return if (mProxy) threadPoolExecutor.submit(task) else super.submit(task)
    }

    override fun execute(command: Runnable) {
        if (mProxy) threadPoolExecutor.execute(command) else super.execute(command)
    }
  
   //注意：不能关闭，否则影响其他被代理的线程池
    override fun shutdown() {
        if (!mProxy) {
            super.shutdown()
        }
    }
    //注意：不能关闭，否则影响其他被代理的线程池
    override fun shutdownNow(): MutableList<Runnable> {
        val list = if (mProxy) mutableListOf<Runnable>() else super.shutdownNow()
        return list
    }

}
3.2.5 实施代理
  1. 在工程最外层创建thread_tracker.gradle，里面可以设置需要代理的线程池白名单。

  1. 通过打印日志就能看出白名单里面的线程池是否被代理成功。

  1. 设置降级开关

（1）设置每个SDK里面细分类名对应的code

（2）在配置系统上设置需要关闭SDK，设置上面对应的code码即可。

（3）在APP初始化的时候尽可能早的获取配置系统上的code字符串

（4）在进行代理的时候，会匹配code字符串，来决定具体的线程池是否进行代理。

3.2.6 代理后的收益
  • 累计减少了大约40条线程的开销

4. 线程栈裁剪

4.1 裁剪方式

创建线程的时候，线程默认的栈空间大小为 1M 左右，经过测试大部分情况下线程内执行的逻辑并不需要这么大的空间，因此线程栈空间减小，可以对内存这块有明显的优化。

接下来我们来看下函数FixStackSize源码，是怎么设置线程栈默认为1M的？

static size_t FixStackSize(size_t stack_size) { 
    //参数是java层中thread 的stack_size默认0
    if (stack_size == 0) {
      stack_size = Runtime::Current()->GetDefaultStackSize();
    }
    // 默认栈大小是 1M
    stack_size += 1 * MB;
    //...
    if (Runtime::Current()->ExplicitStackOverflowChecks()) {
      stack_size += GetStackOverflowReservedBytes(kRuntimeISA);
    } else {
      8k+8K
      stack_size += Thread::kStackOverflowImplicitCheckSize +
          GetStackOverflowReservedBytes(kRuntimeISA);
    }
    //...
    return stack_size;
  }

发现函数的源码实现就是通过 stack_size += 1 * MB 来设置 stack_size 的： 如果我们传入的 stack_size 为 0 时，默认大小就是 1 M ； 如果我们传入的 stack_size 为 -512KB 时，stack_size 就会变成 512KB（1M - 512KB）。 那我们是不是只用带有 stack_size 入参的构造函数去创建线程，并且设置 stack_size 为 -512KB 就行了呢？ 应用中创建线程的地方太多很难一一修改，前面我们已经将应用中的线程部分收敛到自定义的线程池中去了，所以只需要修改自定义线程池中创建的线程方式即可。在我们自定义的 ThreadFactory 中，创建 stack_size 为 - 512 KB 的线程，这么一个简单的操作就能减少线程所占用的虚拟内存。

package com.lalamove.threadtracker.proxy

import java.util.concurrent.ThreadFactory
import java.util.concurrent.atomic.AtomicInteger

open class ProxyThreadFactory : ThreadFactory {
    override fun newThread(runnable: Runnable): Thread {
        val mAtomicInteger = AtomicInteger(1)
        return Thread(null, runnable, "Thread-" + mAtomicInteger.getAndIncrement(), -512 * 1024)
    }
}

需要注意是线程栈大小的设置需要根据具体的应用场景来进行调整。 如果线程栈大小设置得过小，可能会导致栈溢出等问题； 如果设置得过大，可能会浪费过多的内存资源。 因此，在进行线程栈大小设置时，我这边会设置一个动态的裁剪值，即使有线上问题，我们也可以进行适当的调整，以保证程序的正常运行。

4.2 裁剪后的收益
  • 通过火山引擎的APP性能分析平台对比发现，内存平均值减少了20M

  • 通过Profiler实测，发现和火山引擎检测结果相近
方式Total（单位：M）Java（单位：M）Native（单位：M）Graphics（单位：M）Stack（单位：M）Code（单位：M）Others（单位：M）
关闭代理492.461.1181.657.90.2144.746.9
开启代理464.358.2158.664.50.113943.8

结语

由于篇幅限制，文档的详解资料太全面，细节内容太多，所以只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！以下是目录截图：

由于整个文档比较全面，内容比较多，篇幅不允许，下面以截图方式展示 。

再附一部分Android架构面试视频讲解：

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

)

结语

由于篇幅限制，文档的详解资料太全面，细节内容太多，所以只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！以下是目录截图：

[外链图片转存中…(img-wDsTty5B-1715637494403)]

由于整个文档比较全面，内容比较多，篇幅不允许，下面以截图方式展示 。

再附一部分Android架构面试视频讲解：

[外链图片转存中…(img-bKskjeTU-1715637494404)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

【文章汇总】嵌入式Linux公众号
嵌入式Linux
01-08 1万+
据悉，深圳某工程师沦为C语言笔试枪手 修改cmdline 把内存改成512MB 上拉电阻的作用 剖析C语言是如何画出这样的三角形的 c语言画谢宾斯基三角形 Linux字符设备驱动实例 哦，这是桶排序 回答一个微信好友的创业问题 Linux-C编程 / 多线程 / 如何终止某个线程？ 想要学好C++有哪些技巧？ 单片机外围模块漫谈之二，如何提高ADC转换精度 多重 for 循环，如何提高效率？ Linus 在圣诞节想提前放假做了这些解释，哈哈哈 一步步分析-C语言如何面向对象编程 测试内存对齐对运行速度的影响
【C C++服务器开发】中间件的含义及常用中间件介绍_c+(1)
最新发布
2401_84263208的博客
04-18 1127
DDL 包括 CREATE、DROP、ALTER 等动作。在数据库中使用 CREATE 来创建新表，DROP 来删除表，ALTER 负责数据库对象的修改。例如，创建学生信息表使用以下命令：在实践中，可根据实际情况进行权衡，或者在软件层面提供配置方式，由用户决定如何选择 CAP 策略。CAP 理论可用在不同的层面，可以根据 CAP 原理定制局部的设计策略，例如，在分布式系统中，每个节点自身的数据是能保证 CA 的，但在整体上又要兼顾 AP 或 CP。
探索 Android 多线程优化
weixin_38754349的博客
11-11 672
code小生，一个专注大前端领域的技术平台公众号回复 Android 加入我的技术群作者：灯不利多灯不利多投稿发表，转发等请联系原作者授权首图.png目录.png前言1. 基本介绍 在我学习 Android 多线程优化方法的过程中，发现我对多线程优化的了解太片面。写这篇文章的目的是完善我对 Android 多线程优化方法的认识，分享这篇文章的目的是希望大家也能从这些知识从得到一些启发。这篇文章分为...
Android 性能优化：多线程
张拭心的博客 shixinzhang
11-12 9929
前言 Android 开发中多线程的必要性 理解 Android 多线程 MessageQueue Looper Handler HandlerThread Android 中为什么只允许在主线程更新 UI Android 系统为了避免过度复杂的线程安全问题特地规定只允许在主线程中更新 UI 而开发者为了避免上述问题需要注意的是 总结 Thanks前言Android Performance Patt
Android线程优化
OldApple_MrZ的博客
10-22 925
Android线程优化线程调度原理调度模型Android线程调度nice值cgroup注意Android异步线程几种方式线程池线程池使用准则如何锁定线程创建者统一线程库 线程调度原理 任意时刻 ,只有一个线程占用CPU,处于运行状态 多线程并发 :轮流获取CPU使用权 JVM负责线程调度:按照特定机制分配CPU使用权 调度模型 分时调度模型:轮流获取,均分cpu时间 抢占调度模型 :优先级高...
Android 性能优化-线程优化
Chents
07-08 340
在某一刻，只有一个线程占用一个CPU，处理任务。多线程是多个任务被CPU闪速切换执行任务。 分时调度模式：轮流获取、均分CPU时间。 抢占式调度模型：优先级高的获取 1.HandlerThread 自带消息循环，串行执行，长时间运行，不断获取任务。 2.IntentSerivice 优先级高，不容易被杀死 3.AsyncTask 4.线程池 对线程进行命名。便于管理和查找 重视优先级 5 Rxjava 6. 监控创建Thread 监控创建Thread，避免滥用thread。可以使用Hook手段 Dexpo
Android 多线程优化方法
CVSDN的博客
12-24 522
链接出自：https://www.sohu.com/a/333326493_465908 目录.png前言1. 基本介绍 在我学习 Android 多线程优化方法的过程中，发现我对多线程优化的了解太片面。 写这篇文章的目的是完善我对 Android 多线程优化方法的认识，分享这篇文章的目的是希望大家也能从这些知识从得到一些启发。 这篇文章分为下面三部分。 第一部分 第一部分讲的是多...
Java学习专栏！全网最牛！
weixin_70730532的博客
08-12 3396
00254:《SpringCloud Alibaba微服务实战十四 - SpringCloud Gateway集成Oauth2.0》00242:《SpringCloud Alibaba微服务实战二十四 - SpringCloud Gateway的全局异常处理》00251:《SpringCloud Alibaba微服务实战十五 - SpringCloud 容器化部署》00248:《SpringCloud Alibaba微服务实战十八 - Oauth2.0 自定义授权模式》00184:《TCP网络那点破事！..
【面试题】Java基础篇-常见面试题总结p2
2401_84048290的博客
04-18 911
我们总是喜欢瞻仰大厂的大神们，但实际上大神也不过凡人，与菜鸟程序员相比，也就多花了几分心思，如果你再不努力，差距也只会越来越大。实际上，作为程序员，丰富自己的知识储备，提升自己的知识深度和广度是很有必要的。
8w 字，给程序员的职场第一课（上篇）
热门推荐
GitChat
07-07 1万+
本文适合正处在大学阶段，准备毕业以及已经毕业的朋友，对于职场选择，成长方向感兴趣的相关人士。 学完此课程，你能够明白你的学习方向，技巧，以及提前知道职场需要怎么突围，成长，提升，为自己突围职场，制定自己的计划。 同时，文章里面给出了一些我的职场经历，希望能够让大家对程序员这个圈子有所深入理解。总计 30 讲，这一篇是上篇，目录清单： 前言：关于职场，你需要不断拼搏 大学最重要的 8 件事 大公司...
Android 线程性能优化方法总结
m0_56255097的博客
01-23 1257
本篇文字性内容偏多，其实很多技术都是常用的，而且是通用手段，这里相当做了总结，方便大家参考，当然，性能优化方面，有很多地方和I/O优化交叉的，后续我们专门梳理下I/O优化的。另外其实还有些非通用的，如相似照片算法、相同照片算法、搜索树其本质很需求有关，后续有机会我们也整理一下。如果想要成为架构师或想突破20~30K薪资范畴，那就不要局限在编码，业务，要会选型、扩展，提升编程思维。此外，良好的职业规划也很重要，学习的习惯很重要，但是最重要的还是要能持之以恒，任何不能坚持落实的计划都是空谈。
Android性能优化之多线程
qq_33336787的博客
08-05 666
本文主要介绍了AsyncTask, HandlerThread, IntentService与ThreadPool分别适合的场景以及各自的使用注意事项。 一，线程性能 在程序开发的实践当中，为了让程序表现得更加流畅，我们肯定会需要使用到多线程来提升程序的并发执行性能。但是编写多线程并发的代码一直以来是一个相对棘手的问题。 为主线程减轻负担的多线程方案有哪些？这些方案分别适合在什么场景下使用？
线程优化
辉的范你学不来的博客
03-20 1902
无限制创建线程 Web服务器中，在正常负载情况下，为每个任务分配一个线程，能够提升串行执行条件下的性能。只要请求的到达率不超出服务器的请求处理能力，那么这种方法可以同时带来更快的响应性和更高的吞吐率。如果请求的到达速率非常高，且请求的处理过程是轻量级的，那么为每个请求创建一个新线程将消耗大量的计算资源。 引发的问题 线程的生命周期开销非常高 消耗过多的CPU资源 如果可运行的线程数量多于可用处理器...
Android关于线程优化以及性能优化的一些建议
郑敏
08-19 2491
关于Android线程优化和性能优化一些idea！
Android 性能优化<八> 多线程优化和线程管理
深南大盗的博客
09-01 1457
AsyncTask:为 UI 线程与工作线程之间进行快速的切换提供一种简单便捷的机制。适用于当下立即需要启动，但是异步执行的生命周期短暂的使用场景。 HandlerThread:为某些回调方法或者等待某些任务的执行设置一个专属的线程，并提供线程任务的调度机制。 ThreadPool:把任务分解成不同的单元，分发到各个不同的线程上，进行同时并发处理。 IntentService:适合于...
探索 Android 多线程优化方法
Android062002的博客
07-01 683
前言 1. 基本介绍 在我学习 Android 多线程优化方法的过程中，发现我对多线程优化的了解太片面。 写这篇文章的目的是完善我对 Android 多线程优化方法的认识，分享这篇文章的目的是希望大家也能从这些知识从得到一些启发。 这篇文章分为下面三部分。 第一部分 第一部分讲的是多线程优化的基础知识，包括线程的介绍和线程调度基本原理的介绍。 第二部分 第二部分讲的是多线程优化需要预防的一些问题，包括线程安全问题的介绍和实现线程安全的办法。 第三部分 第三部分讲的是多线程优化可以使用的一些方..
Java 6中的线程优化真的有效么？
cpongo5
10-22 241
介绍 — Java 6中的线程优化\Sun、IBM、BEA和其他公司在各自实现的Java 6虚拟机上都花费了大量的精力优化锁的管理和同步。诸如偏向锁（biased locking）、锁粗化（lock coarsening）、由逸出（escape）分析产生的锁省略、自适应自旋锁（adaptive spinning）这些特性，都是通过在应用程序线程之间更高效地共享数据，从而提高并发效率。尽管这些特性都...
Android线程优化之线程池的详解
刘桂林的博客
05-27 817
本文授权发布公众号【刘桂林】，星球【Hi Android】 ThreadPoolExecutor还是有很多可讲的，但是我选择的还是着重讲解Android中的四个线程池，网上对ThreadPoolExecutor的例子太多了，也比较杂，大家可以去看看。 Android中的线程池的概念来源于Java中的Executor，Executor是一个接口，真正的线程池的实现为ThreadPoolExecu...
2.线程优化
阿叶啊的博客
09-17 353
Tomcat 线程优化 在server.xml中 如: maxThreads=“X” 表示最多同时处理X个连接 minSpareThreads=“X” 初始化X个连接 maxSpareThreads=“X” 表示如果最多可以有X个线程，一旦超过X个,则会关闭不在需要的线程 acceptCount=“X” 当同时连接的人数达到maxThreads时,还可以排队,队列大小为X.超过X就不处理 ...
华为w770 Android RIL移植代码学习指南
由于文件信息中提到了一个名为“ril”的压缩包文件，我们可以推测这个压缩包包含了华为W770 RIL移植的代码。以下是RIL移植代码中可能涉及的关键部分： - **ril.cpp**：RILD守护进程的主程序文件，负责启动和管理与...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值