07/29
2013

Java(Android)线程池

介绍new Thread的弊端及Java四种线程池的使用,对Android同样适用。本文是基础篇,后面会分享下线程池一些高级功能。

1、new Thread的弊端
执行一个异步任务你还只是如下new Thread吗?

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
创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。示例代码如下:

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
创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。示例代码如下:

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
创建一个定长线程池,支持定时及周期性任务执行。延迟执行示例代码如下:

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {

	@Override
	public void run() {
		System.out.println("delay 3 seconds");
	}
}, 3, TimeUnit.SECONDS);

表示延迟3秒执行。

 

定期执行示例代码如下:

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, 优先级)执行。示例代码如下:

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线程响应的操作。

您可以使用这些 HTML 标签和属性: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>

50 thoughts on “Java(Android)线程池

  1. 好吧不好意思没看到辊与里面写到您QQ不回复;是这样的, 我在一个简单demo中用了一个newFixedThreadPool线程池 很奇怪现象发生了:我做的是一个抓站的操作,有个线程池我设置了50个线程,一开始的时候, 跑的好好地,后来线程越来越慢阅历啊越慢 最后就不跑了,,

  2. 楼主大大,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 中邮件要中文介绍

        • Android 3.0之后AsyncTask最大同时执行的线程数未必是1个,而是和设备核心数有关(具体可看AsyncTask#THREAD_POOL_EXECUTOR常量的初始化)。SerialExecutor#execute方法没有创建新的线程,说明execute方法在当前线程中执行。SerialExecutor#execute方法具体的执行动作为:1.添加任务到任务列表;2.取出任务在THREAD_POOL_EXECUTOR中执行。SerialExecutor#execute方法在当前线程执行,且执行动作只是添加任务和让AsyncTask#THREAD_POOL_EXECUTOR执行任务。那么在AsyncTask#execute方法中完全可以通过几行代码实现SerialExecutor#execute的功能,而非创建一个静态内部类来实现。我认为,创建SerialExecutor这个静态内部类的目的,其实是为了兼容AsyncTask#executeOnExecutor方法。

        • 今天,写了一个关于AsyncTask的demo,发现通过AsyncTask#execute执行的任务,是顺序执行的。通过这个demo发现AsyncTask#execute确实是单队列执行任务,虽然是单队列,但是执行任务的线程来自AsyncTask#THREAD_POOL_EXECUTOR,执行每一个任务的线程是随机的、是变化的。重新看了代码,发现对SerialExecutor#execute的理解错误。SerialExecutor#execute只由AsyncTask#execute来调用,而且通过SerialExecutor#mActive来判断是否命令AsyncTask#THREAD_POOL_EXECUTOR执行任务。我之前的理解是,SerialExecutor#execute只要被调用了,就会命令AsyncTask#THREAD_POOL_EXECUTOR执行任务。这一点是错误的。AsyncTask#THREAD_POOL_EXECUTOR是否执行任务是由SerialExecutor#mActive是否为null来确定的。只有SerialExecutor#mTasks中的任务被执行完之后,SerialExecutor#mActive才会为null。SerialExecutor#mTasks中的任务是SerialExecutor#execute中的一个匿名内部类,任务内容是:执行Runnable(SerialExecutor#execute的参数),完成之后命令AsyncTask#THREAD_POOL_EXECUTOR从SerialExecutor#mActive继续取出任务执行。从而实现了单队列的任务执行。当SerialExecutor#mTasks中没有任务时,SerialExecutor#mActive为null。此时添加任务,会执行SerialExecutor#scheduleNext,AsyncTask#THREAD_POOL_EXECUTOR开始取出任务开始执行。执行完毕,发现SerialExecutor#mTasks中没有任务,SerialExecutor#mActive为null,AsyncTask#THREAD_POOL_EXECUTOR也就暂停了。当SerialExecutor#mTasks中有任务时,SerialExecutor#mActive将不为null。此时添加任务,就不会执行SerialExecutor#scheduleNext,因此也就不会导致AsyncTask#THREAD_POOL_EXECUTOR会执行新的任务。之前对SerialExecutor理解确实存在错误的认知。SerialExecutor确实是单任务队列,但不是单线程的。所以,3.0版本之后的AsyncTask#execute也确实是单队列地执行任务。