java 爪哇(安卓)线程池

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java 爪哇(安卓)线程池相关的知识,希望对你有一定的参考价值。

Java(Android)线程池
介绍new Thread的弊端及Java四种线程池的使用,对Android同样适用。本文是基础篇,后面会分享下线程池一些高级功能。
1、new Thread的弊端
执行一个异步任务你还只是如下new Thread吗?
Java

          new 
            
          Thread 
          ( 
          new 
            
          Runnable 
          ( 
          ) 
            
          { 
         
 
         

             
         
 
         
 
            
          @Override 
         
 
         
 
            
          public 
            
          void 
            
          run 
          ( 
          ) 
            
          { 
         
 
         
 
            
          // TODO Auto-generated method stub 
         
 
         
 
            
          } 
         
 
         
 
          } 
          ) 
          . 
          start 
          ( 
          ) 
          ; 
         
 
        
那你就out太多了,new Thread的弊端如下:
a. 每次new Thread新建对象性能差。
b. 线程缺乏统一管理,可能无限制新建线程,相互之间竞争,及可能占用过多系统资源导致死机或oom。
c. 缺乏更多功能,如定时执行、定期执行、线程中断。
相比new Thread,Java提供的四种线程池的好处在于:
a. 重用存在的线程,减少对象创建、消亡的开销,性能佳。
b. 可有效控制最大并发线程数,提高系统资源的使用率,同时避免过多资源竞争,避免堵塞。
c. 提供定时执行、定期执行、单线程、并发数控制等功能。
 
2、Java 线程池
Java通过Executors提供四种线程池,分别为:
newCachedThreadPool创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。
newFixedThreadPool 创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池,支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
(1). newCachedThreadPool
创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。示例代码如下:
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
         
 
          ExecutorService  
          cachedThreadPool 
            
          = 
            
          Executors 
          . 
          newCachedThreadPool 
          ( 
          ) 
          ; 
         
 
         
 
          for 
            
          ( 
          int 
            
          i 
            
          = 
            
          0 
          ; 
            
          i 
            
          < 
            
          10 
          ; 
            
          i 
          ++ 
          ) 
            
          { 
         
 
         
 
            
          final 
            
          int 
            
          index 
            
          = 
            
          i 
          ; 
         
 
         
 
            
          try 
            
          { 
         
 
         
 
            
          Thread 
          . 
          sleep 
          ( 
          index 
            
          * 
            
          1000 
          ) 
          ; 
         
 
         
 
            
          } 
            
          catch 
            
          ( 
          InterruptedException 
            
          e 
          ) 
            
          { 
         
 
         
 
            
          e 
          . 
          printStackTrace 
          ( 
          ) 
          ; 
         
 
         
 
            
          } 
         
 
         

             
         
 
         
 
            
          cachedThreadPool 
          . 
          execute 
          ( 
          new 
            
          Runnable 
          ( 
          ) 
            
          { 
         
 
         

             
         
 
         
 
            
          @Override 
         
 
         
 
            
          public 
            
          void 
            
          run 
          ( 
          ) 
            
          { 
         
 
         
 
            
          System 
          . 
          out 
          . 
          println 
          ( 
          index 
          ) 
          ; 
         
 
         
 
            
          } 
         
 
         
 
            
          } 
          ) 
          ; 
         
 
         
 
          } 
         
 
        
线程池为无限大,当执行第二个任务时第一个任务已经完成,会复用执行第一个任务的线程,而不用每次新建线程。
 
(2). newFixedThreadPool
创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。示例代码如下:
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
         
 
          ExecutorService  
          fixedThreadPool 
            
          = 
            
          Executors 
          . 
          newFixedThreadPool 
          ( 
          3 
          ) 
          ; 
         
 
         
 
          for 
            
          ( 
          int 
            
          i 
            
          = 
            
          0 
          ; 
            
          i 
            
          < 
            
          10 
          ; 
            
          i 
          ++ 
          ) 
            
          { 
         
 
         
 
            
          final 
            
          int 
            
          index 
            
          = 
            
          i 
          ; 
         
 
         
 
            
          fixedThreadPool 
          . 
          execute 
          ( 
          new 
            
          Runnable 
          ( 
          ) 
            
          { 
         
 
         

             
         
 
         
 
            
          @Override 
         
 
         
 
            
          public 
            
          void 
            
          run 
          ( 
          ) 
            
          { 
         
 
         
 
            
          try 
            
          { 
         
 
         
 
            
          System 
          . 
          out 
          . 
          println 
          ( 
          index 
          ) 
          ; 
         
 
         
 
            
          Thread 
          . 
          sleep 
          ( 
          2000 
          ) 
          ; 
         
 
         
 
            
          } 
            
          catch 
            
          ( 
          InterruptedException 
            
          e 
          ) 
            
          { 
         
 
         
 
            
          // TODO Auto-generated catch block 
         
 
         
 
            
          e 
          . 
          printStackTrace 
          ( 
          ) 
          ; 
         
 
         
 
            
          } 
         
 
         
 
            
          } 
         
 
         
 
            
          } 
          ) 
          ; 
         
 
         
 
          } 
         
 
        
因为线程池大小为3,每个任务输出index后sleep 2秒,所以每两秒打印3个数字。
定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()。可参考PreloadDataCache。
 
(3) newScheduledThreadPool
创建一个定长线程池,支持定时及周期性任务执行。延迟执行示例代码如下:
Java
1
2
3
4
5
6
7
8
 
         
 
          ScheduledExecutorService  
          scheduledThreadPool 
            
          = 
            
          Executors 
          . 
          newScheduledThreadPool 
          ( 
          5 
          ) 
          ; 
         
 
         
 
          scheduledThreadPool 
          . 
          schedule 
          ( 
          new 
            
          Runnable 
          ( 
          ) 
            
          { 
         
 
         

             
         
 
         
 
            
          @Override 
         
 
         
 
            
          public 
            
          void 
            
          run 
          ( 
          ) 
            
          { 
         
 
         
 
            
          System 
          . 
          out 
          . 
          println 
          ( 
          "delay 3 seconds" 
          ) 
          ; 
         
 
         
 
            
          } 
         
 
         
 
          } 
          , 
            
          3 
          , 
            
          TimeUnit 
          . 
          SECONDS 
          ) 
          ; 
         
 
        
表示延迟3秒执行。
 
定期执行示例代码如下:
Java

          scheduledThreadPool 
          . 
          scheduleAtFixedRate 
          ( 
          new 
            
          Runnable 
          ( 
          ) 
            
          { 
         
 
         

             
         
 
         
 
            
          @Override 
         
 
         
 
            
          public 
            
          void 
            
          run 
          ( 
          ) 
            
          { 
         
 
         
 
            
          System 
          . 
          out 
          . 
          println 
          ( 
          "delay 1 seconds, and excute every 3 seconds" 
          ) 
          ; 
         
 
         
 
            
          } 
         
 
         
 
          } 
          , 
            
          1 
          , 
            
          3 
          , 
            
          TimeUnit 
          . 
          SECONDS 
          ) 
          ; 
         
 
        
表示延迟1秒后每3秒执行一次。
ScheduledExecutorService比Timer更安全,功能更强大,后面会有一篇单独进行对比。
 
(4)、newSingleThreadExecutor
创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。示例代码如下:
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
         
 
          ExecutorService  
          singleThreadExecutor 
            
          = 
            
          Executors 
          . 
          newSingleThreadExecutor 
          ( 
          ) 
          ; 
         
 
         
 
          for 
            
          ( 
          int 
            
          i 
            
          = 
            
          0 
          ; 
            
          i 
            
          < 
            
          10 
          ; 
            
          i 
          ++ 
          ) 
            
          { 
         
 
         
 
            
          final 
            
          int 
            
          index 
            
          = 
            
          i 
          ; 
         
 
         
 
            
          singleThreadExecutor 
          . 
          execute 
          ( 
          new 
            
          Runnable 
          ( 
          ) 
            
          { 
         
 
         

             
         
 
         
 
            
          @Override 
         
 
         
 
            
          public 
            
          void 
            
          run 
          ( 
          ) 
            
          { 
         
 
         
 
            
          try 
            
          { 
         
 
         
 
            
          System 
          . 
          out 
          . 
          println 
          ( 
          index 
          ) 
          ; 
         
 
         
 
            
          Thread 
          . 
          sleep 
          ( 
          2000 
          ) 
          ; 
         
 
         
 
            
          } 
            
          catch 
            
          ( 
          InterruptedException 
            
          e 
          ) 
            
          { 
         
 
         
 
            
          // TODO Auto-generated catch block 
         
 
         
 
            
          e 
          . 
          printStackTrace 
          ( 
          ) 
          ; 
         
 
         
 
            
          } 
         
 
         
 
            
          } 
         
 
         
 
            
          } 
          ) 
          ; 
         
 
         
 
          } 
         
 
        
结果依次输出,相当于顺序执行各个任务。
现行大多数GUI程序都是单线程的。Android中单线程可用于数据库操作,文件操作,应用批量安装,应用批量删除等不适合并发但可能IO阻塞性及影响UI线程响应的操作。
Posted@2013-07-29 08:50:11, Filed under Android, Java, 性能优化 by Trinea
Post navigation? 上一篇: android公共库——图片缓存 网络缓存 下拉及底部更多listview 公共类   ? 下一篇: edittext初始不获得焦点及输入框被遮挡问题   
被顶起来的评论
Trinea
Trinea
陈燮轲
陈燮轲 2014年2月15日 1楼             
楼主大大,AsyncTask内部也是用线程池实现的吧。但是AsyncTask也有缺陷(内部设定核心工作线程只有5,而且会重复执行异步任务。。。),不能过多依赖。我现在就太依赖AsyncTask了,因为它的封装确实不错(额,我偷懒了)。所以现在需要重新学习线程方面的知识,需要更安全,更方便的线程工具。不知道楼主有没有对AsyncTask封装的很好的工具类,希望楼主大大指条路给我。。。阿里嘎多。。。       
嗯,AsyncTask是ThreadPoolExecutor实现的,Executors主要也是ThreadPoolExecutor实现的。AsyncTask的核心线程大小是5,不过等待队列可以到128。至于你说的会重复执行异步任务的情况应该不会,可能是你使用不当,你可以给我看看示例

我平时更多的是自己使用上面的几个线程池,偶尔也用AsyncTask。如果你是因为核心工作线程太小的话可以通过AsyncTask的setDefaultExecutor参数重新设置线程池。

网上有个https://github.com/BoltsFramework/Bolts-Android/ 开源项目你也可以看看,没有亲自用过,它的优点我在https://github.com/Trinea/android-open-project 中邮件要中文介绍

以上是关于java 爪哇(安卓)线程池的主要内容,如果未能解决你的问题,请参考以下文章

用复杂的子例程杀死一个线程。爪哇

安卓线程池ThreadPoolExecutor的常见使用

Android线程池的使用

安卓下多线程OpenGL共享Context

线程池的一些面试题

安卓Android开发:使用Executor线程池代替AsyncTask进行异步操作