android 线程池的使用以及Executors的优缺点

最新推荐文章于 2024-09-11 16:42:23 发布
最新推荐文章于 2024-09-11 16:42:23 发布
阅读量3.6k 收藏 2
点赞数
分类专栏： android开发 文章标签： 线程池 android开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/duolaimila/article/details/78732535
版权

android开发，大家最熟悉的肯定是主线程，也就是ui线程，也都知道在非ui线程更新界面会报错提示不允许在子线程更新ui。但是耗时操作还是需要使用子线程，例如：

new Thread(new Runnable() {
    @Override
    public void run() {
        // TODO Auto-generated method stub
    }
}).start();

感觉方便直接，在任务结束后GC也会自动回收该线程，不过它还在存在很大的弊端

  1. 如果某个地方需要开启大量的线程。创建线程和销毁线程是需要时间的，这样会导致性能不足
  2. 线程无法管理，相互竞争导致卡顿或者oom
  3. 功能太过单一

所以针对这些问题，我们需要重用线程，使用线程池。

线程池：ThreadPoolExecutor
先来看看构造函数：

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)
  • corepoolsize：核心线程数
  • maximumPoolSize：最大线程数
  • keepAliveTime：线程空闲时间
  • unit：keepAliveTime的时间单位
  • workQueue：阻塞任务队列
  • threadFactory：新建线程工厂
  • RejectedExecutionHandler：当提交当提交任务数超过maxmumPoolSize+workQueue之和时，任务会交给RejectedExecutionHandler来处理

配置起来还是比较繁琐，所以官方提供了一个类Executors来帮助我们迅速创建我们需要的线程池，比较常见的有：

1：newFixedThreadPool() ：
该方法返回一个固定线程数量的线程池，该线程池中的线程数量始终不变，即不会再创建新的线程，也不会销毁已经创建好的线程，自始自终都是那几个固定的线程在工作，所以该线程池可以控制线程的最大并发数。 超出的线程会在队列中等待。
2：newCachedThreadPool：
该方法返回一个可以根据实际情况调整线程池中线程的数量的线程池。如果没有线程不够用则会一直创建，有空闲线程则会复用。
3：newSingleThreadExecutor() ：
顾名思义，返回只有一个线程的线程池。多余的任务会存在队列中等待执行
4：newScheduledThreadPool():
返回一个可以固定线程个数和设置线程延迟执行时间，执行周期 的线程池

好了，来看下具体使用方式：

newFixedThreadPool

ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 100; i++) {
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    Log.i("thread", Thread.currentThread().getName());
                }
            });
        }

规定线程数为3，然后循环执行打印线程名字

12-06 16:29:06.665 15218-15256/? I/thread: pool-1-thread-1
12-06 16:29:06.667 15218-15256/? I/thread: pool-1-thread-1
12-06 16:29:06.667 15218-15257/? I/thread: pool-1-thread-2
12-06 16:29:06.667 15218-15256/? I/thread: pool-1-thread-1
12-06 16:29:06.667 15218-15258/? I/thread: pool-1-thread-3
12-06 16:29:06.667 15218-15256/? I/thread: pool-1-thread-1
12-06 16:29:06.667 15218-15257/? I/thread: pool-1-thread-2
12-06 16:29:06.667 15218-15256/? I/thread: pool-1-thread-1
12-06 16:29:06.667 15218-15257/? I/thread: pool-1-thread-2
12-06 16:29:06.667 15218-15258/? I/thread: pool-1-thread-3
12-06 16:29:06.667 15218-15257/? I/thread: pool-1-thread-2
12-06 16:29:06.667 15218-15256/? I/thread: pool-1-thread-1
12-06 16:29:06.667 15218-15256/? I/thread: pool-1-thread-1
12-06 16:29:06.667 15218-15256/? I/thread: pool-1-thread-1
12-06 16:29:06.667 15218-15256/? I/thread: pool-1-thread-1
12-06 16:29:06.667 15218-15257/? I/thread: pool-1-thread-2
12-06 16:29:06.667 15218-15256/? I/thread: pool-1-thread-1
12-06 16:29:06.667 15218-15258/? I/thread: pool-1-thread-3
12-06 16:29:06.667 15218-15256/? I/thread: pool-1-thread-1
12-06 16:29:06.667 15218-15256/? I/thread: pool-1-thread-1
12-06 16:29:06.667 15218-15258/? I/thread: pool-1-thread-3
12-06 16:29:06.667 15218-15256/? I/thread: pool-1-thread-1

可以看出始终只有三个线程在跑任务，符合预期

newCachedThreadPool

ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 100; i++) {
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    Log.i("thread", Thread.currentThread().getName());
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }

代码差不多，加了一个睡眠时间模拟处理时间，看看控制台部分输出：

12-06 16:33:28.463 15429-15454/? I/thread: pool-1-thread-11
12-06 16:33:28.463 15429-15456/? I/thread: pool-1-thread-13
12-06 16:33:28.464 15429-15457/? I/thread: pool-1-thread-14
12-06 16:33:28.464 15429-15458/? I/thread: pool-1-thread-15
12-06 16:33:28.464 15429-15455/? I/thread: pool-1-thread-12
12-06 16:33:28.464 15429-15468/? I/thread: pool-1-thread-25
12-06 16:33:28.464 15429-15469/? I/thread: pool-1-thread-26
12-06 16:33:28.465 15429-15470/? I/thread: pool-1-thread-27
12-06 16:33:28.465 15429-15471/? I/thread: pool-1-thread-28
12-06 16:33:28.466 15429-15472/? I/thread: pool-1-thread-29
12-06 16:33:28.466 15429-15474/? I/thread: pool-1-thread-30
12-06 16:33:28.467 15429-15476/? I/thread: pool-1-thread-32
12-06 16:33:28.467 15429-15475/? I/thread: pool-1-thread-31
12-06 16:33:28.467 15429-15477/? I/thread: pool-1-thread-33
12-06 16:33:28.467 15429-15478/? I/thread: pool-1-thread-34
12-06 16:33:28.468 15429-15479/? I/thread: pool-1-thread-35
12-06 16:33:28.469 15429-15480/? I/thread: pool-1-thread-36
12-06 16:33:28.469 15429-15481/? I/thread: pool-1-thread-37
12-06 16:33:28.469 15429-15482/? I/thread: pool-1-thread-38
12-06 16:33:28.471 15429-15484/? I/thread: pool-1-thread-40
12-06 16:33:28.471 15429-15483/? I/thread: pool-1-thread-39

因为睡眠时间长导致每次循环都创建一个线程，如果取消sleep时间会看到线程数量没有这么多，因为会复用。

newSingleThreadExecutor

ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 100; i++) {
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    Log.i("thread", Thread.currentThread().getName());
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }

还是差不多的代码，看控制台输出

12-06 16:36:30.480 15693-15708/? I/thread: pool-1-thread-1
12-06 16:36:31.481 15693-15708/? I/thread: pool-1-thread-1
12-06 16:36:32.481 15693-15708/? I/thread: pool-1-thread-1
12-06 16:36:33.482 15693-15708/? I/thread: pool-1-thread-1
12-06 16:36:34.482 15693-15708/? I/thread: pool-1-thread-1
12-06 16:36:35.483 15693-15708/? I/thread: pool-1-thread-1
12-06 16:36:36.483 15693-15708/? I/thread: pool-1-thread-1
12-06 16:36:37.484 15693-15708/? I/thread: pool-1-thread-1
12-06 16:36:38.484 15693-15708/? I/thread: pool-1-thread-1
12-06 16:36:39.484 15693-15708/? I/thread: pool-1-thread-1
12-06 16:36:40.485 15693-15708/? I/thread: pool-1-thread-1
12-06 16:36:41.485 15693-15708/? I/thread: pool-1-thread-1

可以看出每次都是同一个线程在执行，所有任务在排队执行

newScheduledThreadPool

ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);
executorService.schedule(new Runnable() {
            @Override
            public void run() {
                Log.i("thread", Thread.currentThread().getName());
            }
        }, 3000, TimeUnit.MILLISECONDS);

延迟执行，schedule第二三个方法执行时间长度和时间单位

ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);
        executorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                Log.i("thread", Thread.currentThread().getName());
            }
        }, 5000,3000, TimeUnit.MILLISECONDS);

周期性执行，延迟5秒后，每隔3秒执行一次，按照任务开始计算，然后任务执行时间大于间隔时间，则会在任务结束后立马执行下一次。scheduleWithFixedDelay会在任务结束后开始计算间隔时间，和任务执行时间无关.

简单介绍了一下好处，也得来讲讲这种简单创建线程池的方式的缺点：
newFixedThreadPool和newSingleThreadExector：
主要问题是推挤的请求处理队列可能会耗费非常大的内存，甚至导致oom。
newCachedThreadPool和newScheduledThreadPool：
主要问题是线程数没有限制，可能会创建数量非常多的线程，导致oom

im哆来咪
关注
专栏目录
Executors 与 Thread 比较
ZJQ的博客
03-11 734
1.new Thread的弊端如下： a.每次new Thread新建对象性能差。 b.线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机。 c.缺乏更多功能，如定时执行、定期执行、线程中断。 2.Executors 优势： a.重用存在的线程，减少对象创建、消亡的开销，性能佳。 b.可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多...
Android笔记：正确使用线程池及注意的地方
程龙的博客
10-18 1533
从业以来其实我一直对线程池接触的比较少，了解的比较潜，最近也看了看相关的知识，今天呢总结一下线程池的知识。 线程池能有效的处理多个线程的并发问题，避免大量的线程因为互相强占系统资源导致阻塞现象，能够有效的降低频繁创建和销毁线程对性能所带来的开销。 一、简单来说使用线程池有三个好处： 1、降低资源消耗：通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 2、提高响应速度：当任务到达时，任务可以不...
Android中的线程池 ThreadPoolExecutor
weixin_34074740的博客
11-04 123
线程池的优点： 重用线程池中的线程，避免因为线程的创建和销毁带来的性能消耗 能有效的控制线程的最大并发数，避免大量的线程之间因抢占系统资源而导致的阻塞现象 能够对线程进行简单的管理，并提供定时执行以及指定间隔循环执行等功能 ThreadPoolExecutor： Android中，用ThreadPoolExecutor来实现线程池的配置。Threa...
Android 多线程使用及原理（Handler、线程池）
最新发布
qq_51598534的博客
09-11 1433
线程池其实就是一种多线程处理形式，处理过程中可以将任务添加到队列中，然后在创建线程后自动启动这些任务。这里的线程就是我们前面学过的线程,这里的任务就是我们前面学过的实现了Runnable或Callable接口的实例对象;@Overridevolatile：保证变量的可见性，但不保证操作的原子性。：确保代码块或方法在同一时刻只能被一个线程执行，保证互斥访问。：在特定对象上加锁，保证特定对象的互斥访问。：提供了更灵活的锁机制，包括尝试加锁、超时加锁等。
Android ThreadPoolExecutor线程池
fomin
11-20 897
引言 Android的线程池概念来自于Java的Executor，真正的线程池实现为ThreadPoolExecutor。在Android中，提供了4类不同的线程池，具体下面会说到。为什么使用线程池呢？而不是使用Thread创建线程呢？因为使用线程池有以下几个优点： 重用线程池的线程，避免因为线程的创建和销毁所带来的性能开销 能有效控制线程池的最大并发数，避免线程之间抢占资源导致阻塞 能够...
Android之ThreadPoolExecutor
正在Android的学习路上
11-25 672
ThreadPoolExecutor使用
Android API ： ThreadPoolExecutor
Mister_J 记录
09-17 879
ThreadPoolExecutor可以用来延迟或者定时执行任务。当需要运行多个工作线程或者需要通过扩展ThreadPoolExecutor 来增加灵活性和功能时，它优于Timer 类。 延迟任务将会在任务激活后执行，但是不知道具体的执行时间，只要被激活，就会被执行。任务执行的顺序和被提交的顺序相同,是先入先出的顺序（FIFO）。 如果一个被提交的任务在执行前被取消了，这个任务就不会再
android线程池
01-19
在Android开发中，线程池是一种管理线程的机制，它可以帮助我们更高效地调度并发任务，优化系统资源的使用，防止过多线程导致的系统性能下降或崩溃。本篇文章将深入探讨四种主要的线程池类型及其实现，旨在帮助...
深入理解Android多线程开发：场景应用与解决方案解析
喻志强的博客
06-09 225
在专栏之前的文章中，我们了解了并发、线程、线程安全、线程池等多线程开发的概念。本篇文章，我们来梳理一下在Android开发中我们面临的多线程开发中常见的应用场景和解决方案。随着技术的飞速发展，我们在处理多线程相关的业务场景时有了更多选择和更为简洁的解决方案。从早期的线程， Handler，到后来的 RxJava，再到现在的 Kotlin协程，每一代技术都在不断提升我们的开发效率和代码质量。及时更新项目的技术栈，采用新的库和框架，能够显著提高我们的开发效率，同时降低出错的成本。
Android线程池—三大分析法分析线程池
m0_70748458的博客
04-07 488
线程池是一种管理和调度线程的机制，线程池可以控制线程的数量，确保线程有效地工作，并且可以重复使用以前创建的线程，从而减少系统的开销。可以点击“此处”即可免费获取学习资料以及更多Android学习笔记＋源码解析＋面试视频Worker代表一个工作线程，该类实现了Runnable接口，继承自AQS，内部实现了一套简单的锁机制。这里使用的是代理模式，Worker实现了Runnable，然后轮训任务队列，取出任务执行。//代表工作线程//该线程执行的第一个任务//该线程已经执行的任务数量/***/
android(java)四大线程池详解
02-25
Java 和 Android 开发中，线程池是一种高效管理并发任务的机制，它可以克服直接使用 `new Thread` 的诸多缺点。本文将详细介绍四种由 `Executors` 工具类提供的线程池类型及其特点。 1. **new Thread 的弊端** - ...
Android 线程池 ThreadPoolExecutor
Today的博客
10-13 1144
线程池可以解决两个不同问题：由于减少了每个任务调用的开销，它们通常可以在执行大量异步任务时提供增强的性能，并且还可以提供绑定和管理资源（包括执行任务集时使用的线程）的方法。每个 ThreadPoolExecutor 还维护着一些基本的统计数据，如完成的任务数。
Android 中使用 ThreadPoolExecutor
qxf865618770的博客
07-17 1162
线程池执行器以及它们在 Android 中的使用。我们将通过大量示例代码彻底介绍这些主题。虽然现在我们都使用RxJava、Kotlin-Coroutines来执行后台任务，但了解 ThreadPoolExecutor 很重要，因为所有这些库都是在 ThreadPoolExecutor 之上构建的。线程池线程池管理一个工作线程池（具体数量取决于其实现）。任务队列保存等待池中...
Android中的线程池ThreadPoolExecutor
wcl_android@163.com
06-10 734
提到线程池就必须先说一下使用线程池的好处： 1.重用线程池中的线程，避免因为线程的创建和销毁所带来的性能开销； 2.能有效控制线程池的最大并发数，避免大量的线程之间因相互抢占系统资源而导致的阻塞现象； 3.能够对线程进行简单的管理，并提供定时执行以及制定事件间隔循环执行等功能。 Android中的线程池的概念来源于Java中的Executor，Executor是一个接口，真正的线程池的实现为Thre
ThreadPoolExecutor-android线程池
小虎的博客
02-04 446
ThreadPoolExecutor-android线程池
Android多线程:ThreadPoolExecutor
weixin_43038028的博客
05-15 469
Android多线程:ThreadPoolExecutor 构造方法 public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, ...
Android线程池ThreadPoolExechtor
luoj_616的专栏
05-21 491
线程池的作用： 对多个线程进行统一地管理，避免资源竞争中出现的问题。对线程进行复用，线程在执行完任务后不会立刻销毁，而会等待另外的任务，这样就不会频繁地创建、销毁线程和调用GC。JAVA提供了一套完整的ExecutorService线程池创建的api，可创建多种功能不一的线程池，使用起来很方便。 创建线程池（基类ThreadPoolExecutor） public ThreadPoolEx...
Android ThreadPoolExecutor 学会管理你的线程池
IT_MR_JIE的博客
12-05 294
初入Android 时对于线程管理是一无所知。觉得只要可以实现需求就算是完成项目了。但在接触久了之后才发现自己需要学的、做的还有那么那么多。 new Thread(new Runnable() { @Override public void run() { //todo }
android studio 线程池使用
06-08
在 Android Studio 中使用线程池需要以下步骤： 1. 创建一个线程池对象。可以使用 Executors 类中的静态方法来创建线程池对象，例如：`ExecutorService executor = Executors.newFixedThreadPool(3);`，这里创建了一个固定大小为3的线程池。 2. 创建一个实现 Runnable 接口的类，重写 run() 方法，将需要执行的操作放在 run() 方法中。 3. 将 Runnable 对象提交给线程池进行执行，可以使用 execute() 方法或 submit() 方法，例如：`executor.execute(new MyRunnable());`，这里将一个 MyRunnable 对象提交给线程池进行执行。 4. 当不需要使用线程池时，需要调用 shutdown() 方法关闭线程池。例如：`executor.shutdown();` 下面是一个完整的示例代码： ``` public class MainActivity extends AppCompatActivity { private ExecutorService executor; private TextView textView; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); textView = findViewById(R.id.text_view); // 创建线程池对象 executor = Executors.newFixedThreadPool(3); // 提交任务 executor.execute(new MyRunnable()); executor.execute(new MyRunnable()); executor.execute(new MyRunnable()); } @Override protected void onDestroy() { super.onDestroy(); // 关闭线程池 executor.shutdown(); } private class MyRunnable implements Runnable { @Override public void run() { // 在这里执行需要执行的操作 // 可以更新 UI，但需要使用 runOnUiThread() 方法 runOnUiThread(new Runnable() { @Override public void run() { textView.setText("Hello World"); } }); } } } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值