Android的ExecutorService线程池

最新推荐文章于 2024-08-12 04:05:39 发布
最新推荐文章于 2024-08-12 04:05:39 发布
阅读量1.8k 收藏
点赞数
分类专栏： Android 文章标签： android thread command java 多线程 import

android-项目中用到了java5 Executors线程池,网上搜了





一下讲的挺详细【转】

 


  Sun在Java5中，对Java线程的类库做了大量的扩展，其中线程池就是Java5的新特征之一，除了线程池之外，还有很多多线程相关的内容，为多线程的编程带来了极大便利。为了编写高效稳定可靠的多线程程序，线程部分的新增内容显得尤为重要。 

　　有关Java5线程新特征的内容全部在java.util.concurrent下面，里面包含数目众多的接口和类，熟悉这部分API特征是一项艰难的学习过程。目前有关这方面的资料和书籍都少之又少，大所属介绍线程方面书籍还停留在java5之前的知识层面上。 
　　当然新特征对做多线程程序没有必须的关系，在java5之前通用可以写出很优秀的多线程程序。只是代价不一样而已。 
　　线程池的基本思想还是一种对象池的思想，开辟一块内存空间，里面存放了众多(未死亡)的线程，池中线程执行调度由池管理器来处理。当有线程任务时，从池中取一个，执行完成后线程对象归池，这样可以避免反复创建线程对象所带来的性能开销，节省了系统的资源。 

　　在Java5之前，要实现一个线程池是相当有难度的，现在Java5为我们做好了一切，我们只需要按照提供的API来使用，即可享受线程池带来的极大便利。 

　　Java5的线程池分好多种：具体的可以分为两类，固定尺寸的线程池、可变尺寸连接池。 

　　在使用线程池之前，必须知道如何去创建一个线程池，在Java5中，需要了解的是java.util.concurrent.Executors类的API，这个类提供大量创建连接池的静态方法，是必须掌握的。 

一、固定大小的线程池，newFixedThreadPool：

[java]  view plain copy
  1. package app.executors;  
  2.   
  3. import java.util.concurrent.Executors;  
  4. import java.util.concurrent.ExecutorService;  
  5.   
  6. /** 
  7.  * Java线程：线程池 
  8.  *  
  9.  * @author 冯小卫 
  10.  */  
  11. public class Test {  
  12.     public static void main(String[] args) {  
  13.         // 创建一个可重用固定线程数的线程池  
  14.         ExecutorService pool = Executors.newFixedThreadPool(5);  
  15.         // 创建线程  
  16.         Thread t1 = new MyThread();  
  17.         Thread t2 = new MyThread();  
  18.         Thread t3 = new MyThread();  
  19.         Thread t4 = new MyThread();  
  20.         Thread t5 = new MyThread();  
  21.         // 将线程放入池中进行执行  
  22.         pool.execute(t1);  
  23.         pool.execute(t2);  
  24.         pool.execute(t3);  
  25.         pool.execute(t4);  
  26.         pool.execute(t5);  
  27.         // 关闭线程池  
  28.         pool.shutdown();  
  29.     }  
  30. }  
  31.   
  32. class MyThread extends Thread {  
  33.     @Override  
  34.     public void run() {  
  35.         System.out.println(Thread.currentThread().getName() + "正在执行。。。");  
  36.     }  
  37. }  


输出结果：

[html]  view plain copy
  1. pool-1-thread-1正在执行。。。  
  2. pool-1-thread-3正在执行。。。  
  3. pool-1-thread-4正在执行。。。  
  4. pool-1-thread-2正在执行。。。  
  5. pool-1-thread-5正在执行。。。  


改变ExecutorService pool = Executors.newFixedThreadPool(5)中的参数：ExecutorService pool = Executors.newFixedThreadPool(2)，输出结果是：

[html]  view plain copy
  1. pool-1-thread-1正在执行。。。  
  2. pool-1-thread-1正在执行。。。  
  3. pool-1-thread-2正在执行。。。  
  4. pool-1-thread-1正在执行。。。  
  5. pool-1-thread-2正在执行。。。  


从以上结果可以看出，newFixedThreadPool的参数指定了可以运行的线程的最大数目，超过这个数目的线程加进去以后，不会运行。其次，加入线程池的线程属于托管状态，线程的运行不受加入顺序的影响。

 

二、单任务线程池，newSingleThreadExecutor：

仅仅是把上述代码中的ExecutorService pool = Executors.newFixedThreadPool(2)改为ExecutorService pool = Executors.newSingleThreadExecutor();

输出结果：

[html]  view plain copy
  1. pool-1-thread-1正在执行。。。  
  2. pool-1-thread-1正在执行。。。  
  3. pool-1-thread-1正在执行。。。  
  4. pool-1-thread-1正在执行。。。  
  5. pool-1-thread-1正在执行。。。  

可以看出，每次调用execute方法，其实最后都是调用了thread-1的run方法。

 

三、可变尺寸的线程池，newCachedThreadPool：

与上面的类似，只是改动下pool的创建方式：ExecutorService pool = Executors.newCachedThreadPool();


输出：

[html]  view plain copy
  1. pool-1-thread-1正在执行。。。  
  2. pool-1-thread-2正在执行。。。  
  3. pool-1-thread-4正在执行。。。  
  4. pool-1-thread-3正在执行。。。  
  5. pool-1-thread-5正在执行。。。  


这种方式的特点是：可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。

四、延迟连接池，newScheduledThreadPool：

[java]  view plain copy
  1. package app.executors;  
  2.   
  3. import java.util.concurrent.Executors;  
  4. import java.util.concurrent.ScheduledExecutorService;  
  5. import java.util.concurrent.TimeUnit;  
  6.   
  7. /** 
  8.  * Java线程：线程池 
  9.  *  
  10.  * @author 冯小卫 
  11.  */  
  12. public class Test {  
  13.     public static void main(String[] args) {  
  14.         // 创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。  
  15.         ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);  
  16.         // 创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口  
  17.         Thread t1 = new MyThread();  
  18.         Thread t2 = new MyThread();  
  19.         Thread t3 = new MyThread();  
  20.         // 将线程放入池中进行执行  
  21.         pool.execute(t1);  
  22.         // 使用延迟执行风格的方法  
  23.         pool.schedule(t2, 1000, TimeUnit.MILLISECONDS);  
  24.         pool.schedule(t3, 10, TimeUnit.MILLISECONDS);  
  25.   
  26.         // 关闭线程池  
  27.         pool.shutdown();  
  28.     }  
  29. }  
  30.   
  31. class MyThread extends Thread {  
  32.     @Override  
  33.     public void run() {  
  34.         System.out.println(Thread.currentThread().getName() + "正在执行。。。");  
  35.     }  
  36. }  


读者可以尝试改变Executors.newScheduledThreadPool(2)的参数来得到更多的体验，当然，让

[java]  view plain copy
  1. @Override  
  2. public void run() {  
  3.     System.out.println(Thread.currentThread().getName() + "正在执行。。。");  
  4. }  

 

变成一个无限循环，你可以得到更多的关于pool.shutdown()的用法。

 

五：单任务延迟连接池(和上面类似，就不写了)。当然我们也可以自定义线程池，这里就不写了

源自：http://blog.csdn.net/coding_or_coded/article/details/6856014

//

ExecutorService线程池 ExecutorService 建立多线程的步骤： 

1。定义线程类 
class Handler implements Runnable{ 
} 

2。建立ExecutorService线程池 
ExecutorService executorService = Executors.newCachedThreadPool(); 

或者 

int cpuNums = Runtime.getRuntime().availableProcessors(); 
                //获取当前系统的CPU 数目 
ExecutorService executorService =Executors.newFixedThreadPool(cpuNums * POOL_SIZE); 
                //ExecutorService通常根据系统资源情况灵活定义线程池大小 

3。调用线程池操作 
循环操作，成为daemon,把新实例放入Executor池中 
      while(true){ 
        executorService.execute(new Handler(socket)); 
           // class Handler implements Runnable{ 
        或者 
        executorService.execute(createTask(i)); 
            //private static Runnable createTask(final int taskID) 
      } 

execute(Runnable对象)方法 
其实就是对Runnable对象调用start()方法 
（当然还有一些其他后台动作，比如队列，优先级，IDLE timeout，active激活等） 



几种不同的ExecutorService线程池对象 
1.newCachedThreadPool() 
-缓存型池子，先查看池中有没有以前建立的线程，如果有，就reuse.如果没有，就建一个新的线程加入池中 
-缓存型池子通常用于执行一些生存期很短的异步型任务 
因此在一些面向连接的daemon型SERVER中用得不多。 
-能reuse的线程，必须是timeout IDLE内的池中线程，缺省timeout是60s,超过这个IDLE时长，线程实例将被终止及移出池。 
  注意，放入CachedThreadPool的线程不必担心其结束，超过TIMEOUT不活动，其会自动被终止。 

2. newFixedThreadPool 
-newFixedThreadPool与cacheThreadPool差不多，也是能reuse就用，但不能随时建新的线程 
-其独特之处:任意时间点，最多只能有固定数目的活动线程存在，此时如果有新的线程要建立，只能放在另外的队列中等待，直到当前的线程中某个线程终止直接被移出池子 
- 和cacheThreadPool不同，FixedThreadPool没有IDLE机制（可能也有，但既然文档没提，肯定非常长，类似依赖上层的TCP 或UDP IDLE机制之类的），所以FixedThreadPool多数针对一些很稳定很固定的正规并发线程，多用于服务器 
-从方法的源代码看，cache池和fixed 池调用的是同一个底层池，只不过参数不同: 
fixed池线程数固定，并且是0秒IDLE（无IDLE） 
cache池线程数支持0-Integer.MAX_VALUE(显然完全没考虑主机的资源承受能力），60秒IDLE  

3.ScheduledThreadPool 
-调度型线程池 
-这个池子里的线程可以按schedule依次delay执行，或周期执行 

4.SingleThreadExecutor 
-单例线程，任意时间池中只能有一个线程 
-用的是和cache池和fixed池相同的底层池，但线程数目是1-1,0秒IDLE（无IDLE） 

上面四种线程池，都使用Executor的缺省线程工厂建立线程，也可单独定义自己的线程工厂 
下面是缺省线程工厂代码: 
    

static class DefaultThreadFactory implements ThreadFactory { 
        static final AtomicInteger poolNumber = new AtomicInteger(1); 
        final ThreadGroup group; 
        final AtomicInteger threadNumber = new AtomicInteger(1); 
        final String namePrefix; 

        DefaultThreadFactory() { 
            SecurityManager s = System.getSecurityManager(); 
            group = (s != null)? s.getThreadGroup() :Thread.currentThread().getThreadGroup(); 
          
            namePrefix = "pool-" + poolNumber.getAndIncrement() + "-thread-"; 
        } 

        public Thread newThread(Runnable r) { 
            Thread t = new Thread(group, r,namePrefix + threadNumber.getAndIncrement(),0); 
            if (t.isDaemon()) 
                t.setDaemon(false); 
            if (t.getPriority() != Thread.NORM_PRIORITY) 
                t.setPriority(Thread.NORM_PRIORITY); 
            return t; 
        } 
    } 

也可自己定义ThreadFactory，加入建立池的参数中 
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) { 

Executor的execute()方法 
execute() 方法将Runnable实例加入pool中,并进行一些pool size计算和优先级处理 
execute() 方法本身在Executor接口中定义,有多个实现类都定义了不同的execute()方法 
如ThreadPoolExecutor类（cache,fiexed,single三种池子都是调用它）的execute方法如下： 
        
public void execute(Runnable command) { 
        if (command == null) 
            throw new NullPointerException(); 
        if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) { 
            if (runState == RUNNING && workQueue.offer(command)) { 
                if (runState != RUNNING || poolSize == 0) 
                    ensureQueuedTaskHandled(command); 
            } 
            else if (!addIfUnderMaximumPoolSize(command)) 
                reject(command); // is shutdown or saturated 
        } 
    }

YAnG_Linux
关注
专栏目录
JDK1.5之后ExecutorService线程池抛RejectedExecutionException的原因剖析以及解决方案
07-18 285
https://blog.csdn.net/izard999/article/details/8552681 本人亲笔原创, 欢迎转载, 但是转载请注明出处http://blog.csdn.net/izard...
Android——线程管理之ExecutorService
chice的博客
05-15 3076
在Java 5之后，ExecutorService类被引入，主要是为了方便线程的统一管理。ExecutorService的作用ExecutorService其实是一个线程池，它可以接收任务，然后根据配置来分配线程，并控制其调度。分类newCacheThreadPool 这种线程池是无界线程池，即它可以创建任意条线程。 每次创建新线程时，先检查自己的缓存池中有没有，没有才会创建。 它有默认的TimeO
Android线程——使用ExecutorService类来实现线程的管理
weixin_34148508的博客
10-27 238
个人博客CoorChice，https://chenbingx.github.io/ ，最新文章将会首发CoorChice的博客，欢迎探索哦 ! 同时，搜索微信公众号CoorChice，或扫描文章末尾二维码，可以关注我的微信公众号。同期文章也将会优先推送到微信公众号中，以提醒您有新鲜文章出炉。 在Jav...
Android ExecutorService读取数据库方式
最新发布
weixin_41303828的博客
08-12 39
Android 中的 ExecutorService 读取数据库方式 在 Android 开发中，数据库操作通常是一个耗时的过程。如果在主线程中执行这些操作，可能会导致应用的界面卡顿甚至 ANR（Application Not Responding）错误。为了避免这个问题，我们可以使用 ExecutorService 进行...
ExecutorService线程池
abc20899的专栏
05-22 172
ExecutorService 建立多线程的步骤： 1。定义线程类 class Handler implements Runnable{ } 2。建立ExecutorService线程池 ExecutorService executorService = Executors.newCachedThreadPool(); 或者 int cpuNums = Runt...
Android线程管理之ExecutorService线程池
06-23 147
前言： 上篇学习了线程Thread的使用，今天来学习一下线程池ExecutorService。 线程管理相关文章地址： Android线程管理之Thread使用总结 Android线程管理之ExecutorService线程池 Android线程管理之ThreadPoolExecutor自定义线程池 Android线程管理之AsyncTask异步任务 ...
ExecutorService线程池处理for循环
【莉婶】的博客
02-11 3824
参考链接：https://blog.csdn.net/bufanrong/article/details/90295576 功能背景:为提高性能，需要异步执行一个list的数据。 多线程处理过程概述: 利用ExecutorService创建线程池，代码如下： int TOTAL_THREADS = 4;//线程数 //数据库中的1万条数据; List list =...
Android中线程池ExecutorService的使用
wy1987_708的专栏
12-16 2197
这两天看了一下有关线程方面的使用。以前我通常只是通过new Thread(){}.start;来创建一个线程并进行相应的使用，可是没有考虑过当线程过多，从而影响到手机的性能。看了一些有关线程池方面的东西，现在这里写下初步认识，以备以后查阅，个人笔记，如果有朋友有更多了解，请通知我。其中部分文章来自网络转载。 下面先说说直接new Thread的缺点： 1，每次new Thread新建对象就要开
android中线程池dmeo
04-24
线程池的概念源于Java的ExecutorService，Android中主要通过`java.util.concurrent`包下的`ThreadPoolExecutor`类来实现。线程池的基本工作原理包括：接收任务、调度任务、执行任务以及管理线程。 1. **线程池的...
ThreadPoolExecutor的使用和Android常见的4种线程池使用介绍
10-11
ThreadPoolExecutor的使用和Android常见的4种线程池使用介绍
java 线程池
xcw931924821的专栏
02-15 591
ExecutorService线程池 ExecutorService 建立多线程的步骤：    ExecutorService线程池 ExecutorService 建立多线程的步骤：  1。定义线程类  class Handler implements Runnable{  }  2。建立ExecutorService线程池  ExecutorService exe
Android ExecutorService
jiujiea6543的专栏
05-29 4080
x android线程池的理解，晚上在家无事 预习了一下android异步加载的例子，也学习到了一个很重要的东东 那就是线程池+缓存  下面看他们的理解。 [size=1.8em]Handler+Runnable模式 我们先看一个并不是异步线程加载的例子，使用 Handler+Runnable模式。 这里为何不是新开线程的原因请参看这篇文章：Android Runnable 运
Android ExecutorService介绍
ZM_Crazy的专栏
01-11 1691
执行一个异步任务你还是new Thread吗？你知道使用new Thread的弊端吗？ 每次new Thread新建对象性能差。 线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。 缺乏更多功能，如定时执行、定期执行、线程中断。 看了以上我推荐使用ExecutorService 相比new Thread，Java提供的四种线程池的好处在于： 重...
Android之线程池ExecutorService
I_do_can的博客
06-20 886
本文只是记录一些零碎的东西 如果你看过这篇加载网络图片的文章，本篇算是对上一个的一个完善吧 每次new 一个线程，不说你也会想到这么做的坏处： 1. 每次new Thread新建对象性能差。 2. 线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。 3. 缺乏更多功能，如定时执行、定期执行、线程中断。 然后我们要使用Java里提供给我们的线
Android ExecutorService线程池
Working harder, getting stronger!
04-03 773
ExecutorService线程池 ExecutorService 建立多线程的步骤：  1。定义线程类  class Handler implements Runnable{  }  2。建立ExecutorService线程池  ExecutorService executorService = Executors.newCachedThreadPool();
自学Android开发 异步任务和线程池
一个从事Android开发的平凡工程师
11-29 2182
目录 一、异步任务 二、AsyncTask 1、官方文档 2、AsyncTask的使用 三、Handler+ Looper. getMainLooper +Thread/ Executors 四、Thread/ Executors+ Handler+ HandlerThread 五、Thread/ Executors+ Activity. runOnUiThread 六、线程池 1、TheadPoolExecutor 2、newFixedThreadPool 3、newCachedTh
Android 性能优化之异步启动（ExecutorService）
Hello___Sunshine的专栏
06-26 1313
记录一下学习历程。 这里以Application类为例。 我们有三个耗时启动操作，如果将它放置在Oncreate中，那无疑是会增加我们的启动时间，原因是假如设备为四核，那可能分配给我们的就只有两个，相当于是本来有四个人可以工作，但是现在有两人干了四个人的活，因此会增加时间成本，同时对CPU的利用率也不高。 那此时我们可以通过线程池来进行提升效率（ExecutorService），关于Exec...
Android开发-通过ExecutorService构建一个APP使用的全局线程池
Mango先生的博客
11-21 4443
在Android开发中线程的使用肯定是少不了的，因为在主线程是不能做耗时操作的；但是使用线程也不能随意的直接通过new Thrad方式去使用，因为像列表这种页面，有很多的图片需要加载，只能异步执行，如果直接new，那对手机内存的压力可想而知；好在Android给我们提供了线程池这样一个东西用来管理线程的操作；话说Android给我们提供了AsyncTask这样一个类，它内部维护了一个线程池，但是很蛋疼的是这个线程池是串行执行的，做不到并发操作，既然这样我们只有自己来封装下了
android ExecutorService
09-06
- *1* *2* *3* [Android线程管理之ExecutorService线程池](https://blog.csdn.net/dengzou5556/article/details/101607309)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值