android 对线程池的探究

于 2016-06-02 15:43:34 发布
阅读量423 收藏 1
点赞数
分类专栏： android 文章标签： android java 线程池 线程 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_33387077/article/details/51567635
版权

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);
    }
}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值