安卓四种线程池

使用线程池的目的

我们可以对我们开启的线程进行跟进，当我们不需要处理的时候可以将它shutdow掉，同时当我们定义了一个线程池之后，可以复用线程而不需要开启更多线程，开启的thread越多意味着你的app内存消耗越多，速度也就越来越慢，提高现有线程的复用。一般一个线程1MB内存，通常一个进程分配1G的内存，所以最多可以创建1024个线程（但是需要留有一定的内存做其他的事情，所以达不到1024个线程）

代码如下

public class ThreadpoolTest extends Activity implements View.OnClickListener{
    private static ExecutorService mCacheThreadExcutor =null;
    private static final int count =3;
    private static ExecutorService mFixThreadExecutor = null;
    private static ScheduledExecutorService mScheduledThreadExecutor = null; //能和Timer/TimerTask类似，解决那些需要任务重复执行的问题
    private static ExecutorService mSingleThreadExecutor = null;


    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_threadpool);
        initView();
        initExecutorService();

    }

    private void initExecutorService() {
       //ExecutorService  线程池接口
        mCacheThreadExcutor = Executors.newCachedThreadPool(); //可缓存线程池，当线程池大小超过了处理任务所需的线程，那么就会回收部分空闲（一般是60秒无执行）的线程，当有任务来时，又智能的添加新线程来执行
        mFixThreadExecutor = Executors.newFixedThreadPool(count); //固定数量的线程池，每提交一个任务就是一个线程，直到达到线程池的最大数量，然后后面进入等待队列直到前面的任务完成才继续执行
        mScheduledThreadExecutor = Executors.newScheduledThreadPool(count);//大小无限制的线程池，支持定时和周期性的执行线程
        mSingleThreadExecutor = Executors.newSingleThreadExecutor(); //单个线程的线程池，即线程池中每次只有一个线程工作，单线程串行执行任务
    }

    private void initView() {
        findViewById(R.id.cache_thread_executorbtn).setOnClickListener(this);
        findViewById(R.id.fixed_thread_executorbtn).setOnClickListener(this);
        findViewById(R.id.scheduled_thread_executorbtn).setOnClickListener(this);
        findViewById(R.id.single_thread_executorbtn).setOnClickListener(this);
    }

    @Override
    public void onClick(View view) {
        switch (view.getId()){
            case R.id.cache_thread_executorbtn:
                ExecutorServiceThread(mCacheThreadExcutor);
                break;
            case R.id.fixed_thread_executorbtn:
                ExecutorServiceThread(mFixThreadExecutor);
                break;
            case R.id.scheduled_thread_executorbtn:
                ExecutorScheduleServiceThread(mScheduledThreadExecutor);
                break;
            case R.id.single_thread_executorbtn:
                ExecutorServiceThread(mSingleThreadExecutor);
                break;

        }
    }

    private void ExecutorScheduleServiceThread(ScheduledExecutorService mScheduledThreadExecutor) {
        for (int i = 0; i < 9; ++i) {
            final int index = i;
            mScheduledThreadExecutor.schedule(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(2*1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    Log.d("ThreadpoolTest","Thread_ScheduledThread"+Thread.currentThread().getId()+"activeCount:"+Thread.activeCount()
                            +" index "+index);
                }
            },2,TimeUnit.SECONDS);
        }
    }

    private void ExecutorServiceThread(ExecutorService executorService) {
        for (int i =0;i<9;++i){
            final  int index =i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(2*1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    Log.d("ThreadpoolTest","Thread"+Thread.currentThread().getId()+"activeCount:"+Thread.activeCount()
                    +" index "+index);
                }
            });
        }
    }
}

总结

1. Executors.newCachedThreadPool()：可缓存线程池，当线程池大小超过了处理任务所需的线程，那么就会回收部分空闲（一般是60秒无执行）的线程，当有任务来时，又智能的添加新线程来执行
2. Executors.newFixedThreadPool(count)：固定数量的线程池，每提交一个任务就是一个线程，直到达到线程池的最大数量，然后后面进入等待队列直到前面的任务完成才继续执行
3. Executors.newScheduledThreadPool(count)：大小无限制的线程池，支持定时和周期性的执行线程
4. Executors.newSingleThreadExecutor(); 单个线程的线程池，即线程池中每次只有一个线程工作，单线程串行执行任务