2.Android 多线程(二)线程池okttp, glide线程池解析(2024精华版)

目录

1. 使用多线程的优点和缺点

2. 线程池的总类和创建

3. 线程池的工作原理

3.5 excute()比较 submit()

4. 自定义线程池, 把功能发挥到最大

5.glide的线程池是怎么封装的?

6.okhttp的线程池是怎么封装的?

7. 线程池如何优化

8. 一些核心的问题

1. 使用多线程的优点和缺点

1. 1 为什么使用线程池

在android开发中经常会使用多线程异步来处理相关任务,而如果用传统的newThread来创建一个子线程进行处理,会造成一些严重的问题:

1:(性能)在任务众多的情况下,系统要为每一个任务创建一个线程,而任务执行完毕后会销毁每一个线程,所以会造成线程频繁地创建与销毁。

2:(性能2)多个线程频繁地创建会占用大量的资源,并且在资源竞争的时候就容易出现问题,同时这么多的线程缺乏一个统一的管理,容易造成界面的卡顿。

3: (性能3)多个线程频繁地销毁,会频繁地调用GC机制,这会使性能降低,又非常耗时。

  1. (功能) 不利于扩展,比如如定时执行、定期执行、线程中断

总而言之:频繁地为每一个任务创建一个线程,缺乏统一管理,降低性能,并且容易出现问题。

  • 多线程的优点:

    • 方便高效的内存共享 - 多进程下内存共享比较不便,且会抵消掉多进程编程的好处
    • 较轻的上下文切换开销 - 不用切换地址空间,不用更改CR3寄存器,不用清空TLB
    • 线程上的任务执行完后自动销毁
  • 多线程的缺点:

    • 开启线程需要占用一定的内存空间(默认情况下,每一个线程都占512KB)
    • 如果开启大量的线程,会占用大量的内存空间,降低程序的性能
    • 线程越多,cpu在调用线程上的开销就越大
    • 程序设计更加复杂,比如线程间的通信、多线程的数据共享
  • 综上得出,多线程不一定能提高效率,在内存空间紧张的情况下反而是一种负担,因此在日常开发中,应尽量

    • 不要频繁创建,销毁线程,使用线程池
    • 减少线程间同步和通信(最为关键)
    • 避免需要频繁共享写的数据
    • 合理安排共享数据结构,避免伪共享(false sharing)
    • 使用非阻塞数据结构/算法
    • 避免可能产生可伸缩性问题的系统调用(比如mmap)
    • 避免产生大量缺页异常,尽量使用Huge Page
    • 可以的话使用用户态轻量级线程代替内核线程
1.2 使用线程池的好处可以归纳为3点:

1). (节约系统的开销)重用线程池中的线程, 避免因为线程的创建和销毁所带来的性能开销.减少GC,内存抖动减少,减少卡顿

2).(提高性能,吞吐量)可有效控制最大并发线程数,提高系统资源的使用率,同时避免过多资源竞争,避免堵塞

3). 能够对线程进行简单的管理,提供定时执行、定期执行、单线程、并发数控制等功能

2. 线程池的总类和创建

2.1 继承关系图

类图.jpg

Executor

ExecutorService

ThreadPoolExecutor

Executors

ThreadPoolExecutor和Executors的关系:

他们之间的联系:android中的线程池都是直接或是间接通过配置ThreadPoolExecutor来实现的.

ExecutorService mThreadPool = Executors.newFixedThreadPool(3);
public class Executors {
    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

2.2 5种线程池

ThreadPoolExecutor

不建议用ThreadPoolExecutor threadPoolExecutor= new ThreadPoolExecutor ();

而是用Executors工厂类方法

Executors类提供了4个工厂方法用于创建4种不同特性的线程池给开发者用.

区别:线程池的长度(线程的个数),可回收,是否处于等待状态,是否支持周期性

5种线程池, 2个是定期执行的! 其他3个是常用的!

(1)newCachedThreadPool 创建一个可缓存线程池,线程池的最大长度无限制,但如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。

缺点: 主要问题是线程数最大数是Integer.MAX_VALUE,可能会创建数量非常多的线程,

  创建线程影响cpu,可以创建无限的线程数。 

(2)newFixedThreadPool 创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。

缺点: 主要问题是堆积的请求处理队列可能会耗费非常大的内存,甚至OOM。

 缺点:主要是里面是个没有边界的队列,导致有存储,就会导致oom 

(3)newSingleThreadExecutor 创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

缺点: 主要问题是堆积的请求处理队列可能会耗费非常大的内存,甚至OOM。

 缺点:主要是里面是个没有边界的队列,导致有存储,就会导致oom 

(4)newScheduledThreadPool 创建一个定时线程池,支持定时及周期性任务执行。

(5) newSingleThreadScheduledExecutor() 看下3个原代码,特别是队列

5线程池.jpg

3. 线程池的工作原理

3.1 工作原理

里面的主要的几个参数发现.线程池的工作原理都是根据构造函数的值弄的。

5大参数,可以通过okhttp的线程池了解下

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

源码:

  if (command == null)
            throw new NullPointerException();
        int c = ctl.get();
        //判断当前活跃线程数是否小于corePoolSize
        if (workerCountOf(c) < corePoolSize) {
            //如果小于,则调用addWorker创建线程执行任务
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        //如果大于等于corePoolSize,则将任务添加到workQueue队列。
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        //如果放入workQueue队列失败,则创建非核心线程执行任务    
        else if (!addWorker(command, false))
            //(如果这时创建线程失败(当前线程数大于等于maximumPoolSize时))
            调用reject拒绝接受任务
            reject(command);

工作策略:

1、如果正在运行的线程数 < coreSize,或者正在运行线程==0,马上创建核心线程执行该task,不排队等待;(直接运行)

2、如果正在运行的线程数 >= coreSize,把该task放入阻塞队列;安排到workQueue中等待执行workQueue,可能成功,可能失败(假如队列)
3、(如果队列workQueue已满) && 正在运行的线程数 < maximumPoolSize,创建新的非核心线程执行该task;
4、(如果队列workQueue已满) && 正在运行的线程数 >= maximumPoolSize,线程池调用handler的reject方法拒绝本次提交。抛出RejectExecutionExpection异常。

对应构造函数的5个参数

理解记忆:1-2-3-4对应(核心线程->阻塞队列->非核心线程->handler拒绝提交)。

理解原理: 核心线程------>排队-------->非核心线程-------->拒绝策略

什么时候拒绝提交:最大线程数+队列长度如果小于<任务数(采用拒绝策略)

架构图.jpg
3.1.1 核心线程

举一个生活中最常见的例子,我们如果把核心线程比作一个正式工,那么非核心线程就是一个外包工。正式工没活干没事,但如果外包工没活干了的话是要面临被裁员的。

核心线程 :固定线程数 可闲置 不会被销毁 ThreadPoolExecutor的allowCoreThreadTimeOut属性设置为true时,keepAliveTime同样会作用于核心线程

非核心线程数:非核心线程闲置时的超时时长,超过这个时长,非核心线程就会被回收

3. 1.2 任务队列

常见几种BlockingQueue实现

  1). ArrayBlockingQueue :  有界的数组队列, 先进先出 (数组)

2). LinkedBlockingQueue : 可支持有界/无界的队列(链表实现)
  3). PriorityBlockingQueue : 优先队列,可以针对任务排序
  4). SynchronousQueue : 队列长度为1的队列,和Array有点区别就是:client thread提交到block queue会是一个阻塞过程,直到有一个worker thread连接上来poll task。

   okhttp:高并发,最大吞吐量。SynchronousQueue队列是无容量队列,OkHttp3中的线程池,核心线程数为0,而最大线程数为Integer.MAX_VALUE

举例说明:

<wiz_code_mirror><pre class=" CodeMirror-line " role="presentation">点点滴滴</pre></wiz_code_mirror>

3.1. 3 拒绝策略

handler 拒绝策略,所谓拒绝策略,是指将任务添加到线程池中时,线程池拒绝该任务所采取的相应策略。

什么时候拒绝?当向线程池中提交任务时,如果此时线程池中的线程已经饱和了,而且阻塞队列也已经满了,则线程池会选择一种拒绝策略来处理该任务,该任务会交给RejectedExecutionHandler 处理。

线程池提供了四种拒绝策略:

1).  AbortPolicy:直接抛出异常,默认策略;

2). DiscardPolicy:直接丢弃任务;

3). DiscardOldestPolicy:丢弃阻塞队列中靠最前的任务,并执行当前任务;【丢弃最靠前的任务, (丢弃最老的)】

4). CallerRunsPolicy:用调用者所在的线程来执行任务;

重要是看英文名字:ACDD

通过源码可以了解到上面的四种线程池实际上还是利用 ThreadPoolExecutor 类实现的如果你提交任务时,线程池队列已满,这时会发生什么

  • 如果你使用的LinkedBlockingQueue,也就是无界队列的话,没关系,继续添加任务到阻塞队列中等待执行,因为LinkedBlockingQueue可以近乎认为是一个无穷大的队列,可以无限存放任务;如果你使用的是有界队列比方说ArrayBlockingQueue的话,任务首先会被添加到ArrayBlockingQueue中,ArrayBlockingQueue满了,则会使用拒绝策略RejectedExecutionHandler处理满了的任务,默认是AbortPolicy
3.2 线程池的 顺序:

顺序是这样的,核心线程------队列大小=====非核心线程

一个是添加顺序,一个是执行顺序。他们不一样

执行顺序:核心线程------非核心线程-------队列

3.3 线程池具体案例分析

第一种情况:

固定线程在跑:核心线程和最大线程相同,并且队列无穷大

解析:

任务队列长度为00,所以不会开启额外的5-3=2个非核心线程,如果将任务队列设为25,则前三个任务被核心线程执行,剩下的30-3=27个任务进入队列会满,此时会开启2个非核心线程来执行剩下的两个任务。

我们看到每两秒后,有三个任务被执行。这是因为核心我们设置的核心线程数为3,当多余的任务到来后,会先放入到阻塞队列中,又由于我们设置的阻塞队列容量为60,所以,阻塞队列永远不会满,就不会启动非核心线程。

threadPoolExecutor = new ThreadPoolExecutor(
       3, 3, 60, TimeUnit.SECONDS,
       new LinkedBlockingDeque<Runnable>(60));

for (int i = 0; i < 30; i++) {
   int num = i;
   Runnable runnable = new Runnable() {
       @Override
       public void run() {
           try {
               Thread.sleep(2000);
               Log.d("EXCUTER", "thread name" + Thread.currentThread().getName());
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
   };
   threadPoolExecutor.execute(runnable);
}

第二种情况:

很多线程,运行,okhttp

threadPoolExecutor = new ThreadPoolExecutor(2, 5, 1, TimeUnit.SECONDS, new LinkedBlockingDeque<Runnable>(25));

我们看到这次每隔两秒有五个任务在执行,为什么?这里要根据我们前面线程池的工作原理来分析,

我们有三十个任务需要执行,核心线程数为2,其余的任务放入阻塞队列中,阻塞队列容量为25,剩余任务不超过非核心线程数,当阻塞队列满的时候,就启动了非核心线程来执行。

问题: 线程池 5个核心线程、有界队列大小是5、最大线程数10 , 添加10个任务,执行流程是怎样的?再来10个,执行流程是怎样的?(重点 )

3.4 线程池的线程复用:

这里就需要深入到源码addWorker():它是创建新线程的关键,也是线程复用的关键入口。最终会执行到runWoker,它取任务有两个方式:

  • firstTask:这是指定的第一个runnable可执行任务,它会在Woker这个工作线程中运行执行任务run。并且置空表示这个任务已经被执行。
  • getTask():这首先是一个死循环过程,工作线程循环直到能够取出Runnable对象或超时返回,这里的取的目标就是任务队列workQueue,对应刚才入队的操作,有入有出。

其实就是任务在并不只执行创建时指定的firstTask第一任务,还会从任务队列的中通过getTask()方法自己主动去取任务执行,而且是有/无时间限定的阻塞等待,保证线程的存活。

3.5 任务的提交: excute()比较 submit()

ExecutorService executorService = Executors.newFixedThreadPool(5);

executorService.submit(() -> {
    // 执行任务逻辑
});

// 关闭线程池
executorService.shutdown();
excuter.jpg

从图上可以看出的,submit()其实还是需要调用execute()去执行任务,而submit()和execute()本质上的不同是submit()将包装好的任务进行了返回.

一个是对于Callable,一个是对于Runable

4. 自定义线程池

问题: 会问到不同的场景, 如何使用发能发挥好?

4.1 核心线程的个数和最大线程数量

虽说线程池极大改善了系统的性能,不过创建线程池也是需要资源的,所以线程池内线程数量的大小也会影响系统的性能,大了反而浪费资源,小了反而影响系统的吞吐量,所以我们创建线程池需要把握一个度才能合理的发挥它的优点,通常来说我们要考虑的因素有CPU的数量、内存的大小、并发请求的数量等因素,按需调整。

通常核心线程数可以设为CPU数量+1,而最大线程数可以设为CPU的数量*2+1。

4.2 线程池和任务定义策略

线程IO密集型和CPU密集型区别及线程数的设置 答: CPU密集型任务:在一个任务中,主要做计算,CPU持续在运行,CPU利用率高,具有该特点的任务称为CPU密集型任务。 IO密集型任务:在一个任务中,大部分时间在进行I/O操作,由于I/O速度远远小于CPU,所以任务的大部分时间都在等待IO,CPU利用率低。 CPU密集型任务:线程数为CPU核数。几个线程可以并行执行,不存在线程切换开销,提高CPU利用率,减少线程切换性能损耗。 IO密集型任务:线程数为CPU核数的2倍,在线程进行I/O操作时,其他线程可以继续使用CPU,提高CPU的使用率

高并发、任务执行时间短的业务怎样使用线程池? okhttp那种

并发不高、任务执行时间长的业务怎样使用线程池? 用核心线程并发高、业务执行时间长的业务怎样使用线程池?

关于这个问题,个人看法是:

(1)高并发、任务执行时间短的业务,线程池线程数可以设置为CPU核数+1,减少线程上下文的切换。用okhttp那种

(2)并发不高、任务执行时间长的业务要区分开看:

a)假如是业务时间长集中在IO操作上,也就是IO密集型的任务,因为IO操作并不占用CPU,所以不要让所有的CPU闲下来,可以加大线程池中的线程数目,让CPU处理更多的业务

b)假如是业务时间长集中在计算操作上,也就是计算密集型任务,这个就没办法了,和(1)一样吧,线程池中的线程数设置得少一些,减少线程上下文的切换

(3)并发高、业务执行时间长,解决这种类型任务的关键不在于线程池而在于整体架构的设计,看看这些业务里面某些数据是否能做缓存是第一步,增加服务器是第二步,至于线程池的设置,设置

5.glide的线程池是怎么封装的?

Glide 定制了 4 个 线程池

https://blog.csdn.net/f409031mn/article/details/88921557

6.okhttp的线程池是怎么封装的?

启异步请求方法中就使用到了高并发、高吞吐量的线程池

public synchronized ExecutorService executorService() {
  if (executorService == null) {
    executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS,
        new SynchronousQueue<>(), Util.threadFactory("OkHttp Dispatcher", false));
  }
  return executorService;
}
public final class Dispatcher {
  // 最大请求数
  private int maxRequests = 64;
  // 相同 host 最大请求数
  private int maxRequestsPerHost = 5;
  // 请求执行线程池,懒加载
  private @Nullable ExecutorService executorService;
  // 就绪状态的异步请求队列
  private final Deque<AsyncCall> readyAsyncCalls = new ArrayDeque<>();
  // 运行中的异步请求队列,包括还没完成的请求
  private final Deque<AsyncCall> runningAsyncCalls = new ArrayDeque<>();

  public Dispatcher(ExecutorService executorService) {
      this.executorService = executorService;
  }

  public Dispatcher() {
  }

  public synchronized ExecutorService executorService() {
      if (executorService == null) {
          // 和 CachedThreadPool 很相似
          executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS,
          new SynchronousQueue<Runnable>(), Util.threadFactory("OkHttp Dispatcher", false));
      }
      return executorService;
  }

  synchronized void enqueue(AsyncCall call) {
    // 不超过最大请求数并且不超过 host 最大请求数
    if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
      // 添加到运行中的异步请求队列
      runningAsyncCalls.add(call);
      // 添加到线程池中运行
      executorService().execute(call);
    } else {
      // 添加到就绪的异步请求队列
      readyAsyncCalls.add(call);
    }
  }

  // 当该异步请求结束的时候,会调用此方法,用于将运行中的异步请求队列中的该请求移除并调整请求队列
  // 此时就绪队列中的请求就可以进入运行中的队列
  void finished(AsyncCall call) {
      finished(runningAsyncCalls, call, true);
  }

  private <T> void finished(Deque<T> calls, T call, boolean promoteCalls) {
      int runningCallsCount;
      Runnable idleCallback;
      synchronized (this) {
          if (!calls.remove(call)) throw new AssertionError("Call wasn't in-flight!");
          if (promoteCalls) promoteCalls();
          runningCallsCount = runningCallsCount();
          idleCallback = this.idleCallback;
      }

      if (runningCallsCount == 0 && idleCallback != null) {
          idleCallback.run();
      }
  }

  // 根据 maxRequests 和 maxRequestsPerHost 来调整 runningAsyncCalls 和 readyAsyncCalls
  // 使运行中的异步请求不超过两种最大值,并且如果队列有空闲,将就绪状态的请求归类为运行中。
  private void promoteCalls() {
    // 如果运行中的异步队列不小于最大请求数,直接返回
    if (runningAsyncCalls.size() >= maxRequests) return;
    // 如果就绪队列为空,直接返回
    if (readyAsyncCalls.isEmpty()) return; // No ready calls to promote.
    // 遍历就绪队列并插入到运行队列
    for (Iterator<AsyncCall> i = readyAsyncCalls.iterator(); i.hasNext(); ) {
      AsyncCall call = i.next();

      if (runningCallsForHost(call) < maxRequestsPerHost) {
        i.remove();
        runningAsyncCalls.add(call);
        executorService().execute(call);
      }
      // 运行队列中的数量到达最大请求数,直接返回
      if (runningAsyncCalls.size() >= maxRequests) return;
    }
  }
}

okhttp线程池一:

但是OkHttp3中的线程池,核心线程数为0,而最大线程数为Integer.MAX_VALUE,而使用的是SynchronousQueue队列,这个队列是无容量队列,

那么往这个队列中去添加任务,那么一定会添加失败,那么就会判断当前线程数是否小于最大线程数还是大于等于最大线程数,那么这里一定是小于

,所以会创建新的线程,然后执行任务;但是如果在加入阻塞队列之前,有空闲线程,则优先交由空闲线程执行,因为线程在执行完成之后,依然会存活60s才会销毁。

okhttp线程池二:

可以发现 OkHttp 不是在线程池中维护线程的个数,线程是通过 Dispatcher 间接控制,线程池中的请求都是运行中的请求,这也就是说线程的重用不是线程池控制的,通过源码我们发现线程重用的地方是请求结束的地方 finished(AsyncCall call) ,而真正的控制是通过 promoteCalls 方法, 根据 maxRequests 和 maxRequestsPerHost 来调整 runningAsyncCalls 和 readyAsyncCalls,使运行中的异步请求不超过两种最大值,并且如果队列有空闲,将就绪状态的请求归类为运行中。

7. 一些核心的问题

面试官: 线程池线程是如何保持线程不被回收的?线程池中多余的线程是如何回收的?

其实就是保证核心线程不被终止的?

总结: 包装住Thread的Wroker类的集合,在里面有条件的进行着死循环,线程池当未调用 shutdown 方法时,是通过队列的 take 方法阻塞核心线程(Worker)的 run 方法从而保证核心线程不被销毁的。

getTask 方法做了哪些事:队列中 take 方法的含义是当队列有任务时,立即返回队首任务,没有任务时则一直阻塞当前线程,直到有新任务才返回。

private Runnable getTask() {
    boolean timedOut = false; 
    //无限循环
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);
        // 检查队列是否为空
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            decrementWorkerCount();
            return null;
        }
    //获取运行线程数,根据allowCoreThreadTimeOut决定是否允许定时等待

问题: 线程池有两种手动关闭的方法:

  • shutDown():关闭线程池后不影响已经提交的任务
  • shutDownNow():关闭线程池后会尝试去终止正在执行任务的线程

问题: 如何扫描到创建的线程和线程池?

通过插桩的方式,来查找创建线程池和线程的类名,并把这些类名统一输出到一份txt文档。插桩的框架,我选择的是ASM,因为使用ASM进行插桩具有高效性、灵活性、易用性、兼容性和社区活跃等优点,是一种比较优秀的字节码操作框架,对于提高应用程序的性能和可维护性具有重要意义。

那么通过ASM是如何扫描到的呢?

要扫描到创建线程池的类名,你需要使用ASM的访问者模式(Visitor Pattern)来遍历字节码中的方法和指令。在遍历过程中,当遇到创建线程的指令(如:new java/util/concurrent/ThreadPoolExecutor)时,就可以获取到创建线程的类名。

import org.objectweb.asm.*;

public class ThreadPoolDetectorClassVisitor extends ClassVisitor {
    public ThreadPoolDetectorClassVisitor(int api, ClassVisitor classVisitor) {
        super(api, classVisitor);
    }

    @Override
    public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
        MethodVisitor mv = cv.visitMethod(access, name, desc, signature, exceptions);
        return new ThreadPoolDetectorMethodVisitor(api, mv);
    }

    class ThreadPoolDetectorMethodVisitor extends MethodVisitor {
        public ThreadPoolDetectorMethodVisitor(int api, MethodVisitor methodVisitor) {
            super(api, methodVisitor);
        methodVisitor);
        }

        @Override
        public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf)) {
            if (opcode == Opcodes.INVOKESTATIC && owner.startsWith("java/util/concurrent/Executors")) {
                System.out.println("Detected creation of new ThreadPool!");
            }
            super.visitMethodInsn(opcode, owner, name, desc desc, itf);
        }
    }
}

线程优化

  • 对于APP业务层和自研SDK,我们检查是否真的需要直接new thread,能否用线程池代替,如果必须创建单个线程,那我们创建的时候必须加上线程名,方便排查线程问题。
  • 对于三方SDK,那就可以通过插桩来重命名(名称必须少于16个字符),方便尽快知道该线程是来自哪个SDK

线程池优化

  • 对于APP业务层,我们需要提供常用线程池,例如I/O、CPU、Single、Cache等等线程池,避免开发各自创建重复的线程池。
  • 对于自研SDK,我们尽量让架构组的开发同学提供可以设置自定义线程池的能力,方便我们代理到我们APP业务层的线程池。
  • 对于三方SDK,首先了解有没有提供设置我们自定义线程池的接口,有的话,那就直接设置我们APP业务层的线程池。如果没有这种能力,那我们就进行插桩来进行线程池收敛。在进行三方SDK插桩代理的时候,需要注意三点:
  1. 设置白名单,进行逐步代理。
  2. 针对不同的SDK,要区分是本地任务还是网络任务,这样能明确是代理到I/O线程池还是CPU线程池。
  3. 设置降级开关,方便线上有问题时,及时对单个SDK进行降级处理。
©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成,浏览时请结合常识与多方信息审慎甄别。
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。

相关阅读更多精彩内容

友情链接更多精彩内容