android 对线程池的探究

android 对线程池的探究

本文介绍new Thread的弊端及Java四种线程池的使用

new Thread的弊端

线程池的优点,Executors提供的四种线程池

new CachedThreadPool创建一个可缓存线程池

new FixedThreadPool 创建一个定长线程池

new ScheduledThreadPool 创建一个定长线程池

new SingleThreadExecutor 创建一个单线程化的线程池

CachedThreadPool线程池的一个工具类

1.new Thread的弊端

如果您是如下方式开启子线程，那么存在以下弊端：
1.每次new Thread新建对象性能差。

2.线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。

3.缺乏更多功能，如定时执行、定期执行、线程中断。

new Thread(new Runnable() {

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

2.使用线程池的优点

使用线程池优点
1.重用存在的线程，减少对象的创建、消亡对内存的开销（开启的thread越多意味着你的app内存消耗越多，速度也就越来越慢）。

2.可以有效的控制最大的并发线程数，提高系统资源的使用率，同事避免过多的资源竞争，避免堵塞。

3.提供定时执行、定期执行、单线程等操作。

Executors提供的四种线程池
1.new CachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需，可以灵活回收空闲线程，若无可回收的，则新建线程。

2.new FixedThreadPool创建一个定长的线程池，可控制县城最大并发数，超出的线程会在队列中等待。

3.new ScheduledThread创建一个定长的线程池，制定定时及周期性任务的执行。

4.new SingleThreadExecutor创建一个单线程化的线程池，它只会用唯一的一个工作线程来执行任务，确保所有的任务按照指定的顺序执行。

3.new CachedThreadPool创建一个可缓存线程池

创建一个可缓存线程池，如果线程池长度超过处理需，可以灵活回收空闲线程，若无可回收的，则新建线程。实例如下：

public void newCachedThreadPool() {

ExecutorService service = Executors.newCachedThreadPool();
for (int i = 0; i < 20; i++) {
final int index = i;
try {
Thread.sleep(200);  //休眠时间越长，线程数越少
} catch (InterruptedException e) {
e.printStackTrace();
}
service.submit(new Runnable() {
@Override
public void run() {
Log.e("newCachedThreadPool", "Thread count=" + Thread.activeCount() + "    index=" + index);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
}

线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。

执行结果为：

E/newCachedThreadPool: Thread count=5 index=0

E/newCachedThreadPool: Thread count=6 index=1

E/newCachedThreadPool: Thread count=7 index=2

E/newCachedThreadPool: Thread count=7 index=3

E/newCachedThreadPool: Thread count=7 index=4

E/newCachedThreadPool: Thread count=7 index=5

E/newCachedThreadPool: Thread count=7 index=6

E/newCachedThreadPool: Thread count=7 index=7

E/newCachedThreadPool: Thread count=7 index=8

E/newCachedThreadPool: Thread count=7 index=9

E/newCachedThreadPool: Thread count=7 index=10

E/newCachedThreadPool: Thread count=7 index=11

E/newCachedThreadPool: Thread count=7 index=12

E/newCachedThreadPool: Thread count=7 index=13

E/newCachedThreadPool: Thread count=7 index=14

E/newCachedThreadPool: Thread count=7 index=15

E/newCachedThreadPool: Thread count=7 index=16

E/newCachedThreadPool: Thread count=7 index=17

E/newCachedThreadPool: Thread count=7 index=18

E/newCachedThreadPool: Thread count=7 index=19

4.new FixedThreadPool 创建一个定长线程池

创建一个定长的线程池，可控制县城最大并发数，超出的线程会在队列中等待。

public void newFixedThreadPool() {

ExecutorService service = Executors.newFixedThreadPool(5);
for (int i = 0; i < 20; i++) {
final int index = i;
service.execute(new Runnable() {
@Override
public void run() {
try {
Log.e("newCachedThreadPool", "    index=" + index);
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
}

因为线程池大小为5，每个任务输出index后sleep 3秒，所以每3秒打印5个数字。

执行结果：

E/newCachedThreadPool: index=0

E/newCachedThreadPool: index=1

E/newCachedThreadPool: index=2

E/newCachedThreadPool: index=3

E/newCachedThreadPool: index=4

E/newCachedThreadPool: index=5

E/newCachedThreadPool: index=6

E/newCachedThreadPool: index=7

E/newCachedThreadPool: index=8

E/newCachedThreadPool: index=9

E/newCachedThreadPool: index=10

E/newCachedThreadPool: index=11

E/newCachedThreadPool: index=12

E/newCachedThreadPool: index=13

E/newCachedThreadPool: index=14

E/newCachedThreadPool: index=15

E/newCachedThreadPool: index=16

E/newCachedThreadPool: index=17

E/newCachedThreadPool: index=18

E/newCachedThreadPool: index=19

5.new ScheduledThreadPool 创建一个定长线程池

创建一个定长的线程池，制定定时及周期性任务的执行。

public void newScheduledThreadPool() {

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(4);
scheduledThreadPool.schedule(new Runnable() {
@Override
public void run() {
Log.e("newScheduledThreadPool", "delay 4 seconds ");
}
}, 4, TimeUnit.SECONDS);
}

表示延迟4秒执行。

执行结果：

E/newScheduledThreadPool: delay 4 seconds

例子2：

public void newScheduledThreadPool() {

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(4);
scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
Log.e("newScheduledThreadPool", "delay 4 seconds ");
}
}, 1,4, TimeUnit.SECONDS);
}

表示延迟1秒后每4秒执行一次。执行结果：

E/newScheduledThreadPool: delay 4 seconds

E/newScheduledThreadPool: delay 4 seconds

E/newScheduledThreadPool: delay 4 seconds

E/newScheduledThreadPool: delay 4 seconds

……

6.new SingleThreadExecutor 创建一个单线程化的线程池

创建一个定长的线程池，制定定时及周期性任务的执行。

public void newSingleThreadExecutor() {

ExecutorService service = Executors.newSingleThreadExecutor();
for (int i = 0; i < 20; i++) {
final int index = i;
service.execute(new Runnable() {
@Override
public void run() {
try {
Log.e("newSingleThreadExecutor", "    index=" + index);
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}

结果依次输出，相当于顺序执行各个任务。

执行结果

06-02 15:35:52.703 8989-9408/com.dema.cn.aaas E/newSingleThreadExecutor: index=0

06-02 15:35:53.313 8989-9225/com.dema.cn.aaas E/newSingleThreadExecutor: index=3

06-02 15:35:55.703 8989-9408/com.dema.cn.aaas E/newSingleThreadExecutor: index=1

06-02 15:35:56.313 8989-9225/com.dema.cn.aaas E/newSingleThreadExecutor: index=4

06-02 15:35:58.703 8989-9408/com.dema.cn.aaas E/newSingleThreadExecutor: index=2

06-02 15:35:59.313 8989-9225/com.dema.cn.aaas E/newSingleThreadExecutor: index=5

06-02 15:36:01.703 8989-9408/com.dema.cn.aaas E/newSingleThreadExecutor: index=3

06-02 15:36:02.313 8989-9225/com.dema.cn.aaas E/newSingleThreadExecutor: index=6

06-02 15:36:04.703 8989-9408/com.dema.cn.aaas E/newSingleThreadExecutor: index=4

06-02 15:36:05.313 8989-9225/com.dema.cn.aaas E/newSingleThreadExecutor: index=7

06-02 15:36:07.703 8989-9408/com.dema.cn.aaas E/newSingleThreadExecutor: index=5

06-02 15:36:08.313 8989-9225/com.dema.cn.aaas E/newSingleThreadExecutor: index=8

06-02 15:36:10.703 8989-9408/com.dema.cn.aaas E/newSingleThreadExecutor: index=6

06-02 15:36:11.313 8989-9225/com.dema.cn.aaas E/newSingleThreadExecutor: index=9

06-02 15:36:13.703 8989-9408/com.dema.cn.aaas E/newSingleThreadExecutor: index=7

06-02 15:36:14.313 8989-9225/com.dema.cn.aaas E/newSingleThreadExecutor: index=10

06-02 15:36:16.703 8989-9408/com.dema.cn.aaas E/newSingleThreadExecutor: index=8

06-02 15:36:17.313 8989-9225/com.dema.cn.aaas E/newSingleThreadExecutor: index=11

06-02 15:36:19.703 8989-9408/com.dema.cn.aaas E/newSingleThreadExecutor: index=9

06-02 15:36:20.313 8989-9225/com.dema.cn.aaas E/newSingleThreadExecutor: index=12

06-02 15:36:22.703 8989-9408/com.dema.cn.aaas E/newSingleThreadExecutor: index=10

06-02 15:36:23.313 8989-9225/com.dema.cn.aaas E/newSingleThreadExecutor: index=13

06-02 15:36:25.703 8989-9408/com.dema.cn.aaas E/newSingleThreadExecutor: index=11

06-02 15:36:26.313 8989-9225/com.dema.cn.aaas E/newSingleThreadExecutor: index=14

06-02 15:36:28.713 8989-9408/com.dema.cn.aaas E/newSingleThreadExecutor: index=12

06-02 15:36:29.323 8989-9225/com.dema.cn.aaas E/newSingleThreadExecutor: index=15

06-02 15:36:31.713 8989-9408/com.dema.cn.aaas E/newSingleThreadExecutor: index=13

06-02 15:36:32.323 8989-9225/com.dema.cn.aaas E/newSingleThreadExecutor: index=16

06-02 15:36:34.713 8989-9408/com.dema.cn.aaas E/newSingleThreadExecutor: index=14

06-02 15:36:35.323 8989-9225/com.dema.cn.aaas E/newSingleThreadExecutor: index=17

06-02 15:36:37.713 8989-9408/com.dema.cn.aaas E/newSingleThreadExecutor: index=15

06-02 15:36:38.323 8989-9225/com.dema.cn.aaas E/newSingleThreadExecutor: index=18

06-02 15:36:40.713 8989-9408/com.dema.cn.aaas E/newSingleThreadExecutor: index=16

06-02 15:36:41.323 8989-9225/com.dema.cn.aaas E/newSingleThreadExecutor: index=19

06-02 15:36:43.713 8989-9408/com.dema.cn.aaas E/newSingleThreadExecutor: index=17

06-02 15:36:46.713 8989-9408/com.dema.cn.aaas E/newSingleThreadExecutor: index=18

06-02 15:36:49.713 8989-9408/com.dema.cn.aaas E/newSingleThreadExecutor: index=19

7.CachedThreadPool线程池的一个工具类

public class ThreadPoolManager {

private ExecutorService service;
private ThreadPoolManager() {
service = Executors.newCachedThreadPool();
}
private static volatile ThreadPoolManager manager;
public static ThreadPoolManager getInstance() {
if (null == manager) {
synchronized (ThreadPoolManager.class) {
if (null == manager) {
manager = new ThreadPoolManager();
}
}
}
return manager;
}
public void addTask(Runnable runnable) {
service.submit(runnable);
}
}