Android线程池的使用方法

Android的线程池，起到的作用就是更好的管控线程

今天先讲一下基本用法

一、CashedThreadPool：缓存线程池，能够自动创建，删除线程对象，并且对已生成的线程对象反复利用，减少创建和回收的次数，降低系统开销

先看看构造方法

        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

然后是启动线程方法

            cachedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    Log.d("MainActivity", "Thread Name:" + Thread.currentThread().getName() + " Thread ID:" + Thread.currentThread().getId());
                }
            });

线程池会接受一个Runna对象，然后在线程里运行run方法

二、FixedThreadPool：定量线程池，在构造时会设定线程数量上限，用法和缓存线程池差不多

构造方法

        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(2);

这里的参数“2”就是线程池做能创建线程的上线

用法也是调用execute方法

            fixedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    Log.d("MainActivity", "Thread Name:" + Thread.currentThread().getName() + " Thread ID:" + Thread.currentThread().getId());
                    Log.d("MainActivity", "i:" + tmp);
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });

三、SingleThreadPool：单一线程池，线程池只能有一个线程

构造方法

 ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();

执行线程方法一样我就省略点写，之后会有源码附上

            singleThreadPool.execute(new Runnable() )

四、ScheduleThreadPool：最后一种是一个计划性的线程池，他可以设置延迟多少时间启动线程，也可以设置周期性启动线程

看构造方法

ScheduledExecutorService scheduledThreadPool = Executors.newSingleThreadScheduledExecutor();

注意：这是添加了单个线程限制条件的周期性线程池的构造方法，这次我们用这个举例

我这里有两个使用方法，第一个是延迟，第二个是延迟+周期性，我都写了注释

        //Test1:延迟执行
        /**
         * 第一个参数是Runnable，第二个参数是时间，第三个参数是时间的单位
         */
//        scheduledThreadPool.schedule(new Runnable() {
//            @Override
//            public void run() {
//                Log.d("MainActivity", "TestScheduledThreadPool.run");
//            }
//        }, 3, TimeUnit.SECONDS);

        //Test2:延迟执行，并且周期性执行
        /**
         * 第一个参数是Runnable，第二个参数是延迟时间，第三个参数是巡行间隔，第四个参数是时间的单位
         */
        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                Log.d("MainActivity", "TestScheduledThreadPool.run");
            }
        },2,3,TimeUnit.SECONDS);

好了  其实很简单，我把完整的代码贴一下，布局文件是4个按钮   我就不贴上来了，大家想象一下

package com.ty.threadpool_demo1;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

import butterknife.BindView;
import butterknife.ButterKnife;
import butterknife.OnClick;

public class MainActivity extends AppCompatActivity {

    @BindView(R.id.BTN_Cached)
    Button BTNCached;
    @BindView(R.id.BTN_Fixed)
    Button BTNFixed;
    @BindView(R.id.BTN_Single)
    Button BTNSingle;
    @BindView(R.id.BTN_Scheduled)
    Button BTNScheduled;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ButterKnife.bind(this);
    }

    @OnClick({R.id.BTN_Cached, R.id.BTN_Fixed, R.id.BTN_Single, R.id.BTN_Scheduled})
    public void onClick(View view) {
        switch (view.getId()) {
            case R.id.BTN_Cached:
                //缓存线程池，会自动控制线程数量，自动创建和销毁,并且循环利用已创建的线程
                TestCashedThreadPool();
                break;
            case R.id.BTN_Fixed:
                //在创建线程池的时候会设定最大线程数。
                TestFixedThreadPool();
                break;
            case R.id.BTN_Single:
                //单一线程的线程池
                TestSingleThreadPool();
                break;
            case R.id.BTN_Scheduled:
                //计划性线程池
                TestScheduledThreadPool();
                break;
        }
    }

    private void TestScheduledThreadPool() {
        ScheduledExecutorService scheduledThreadPool = Executors.newSingleThreadScheduledExecutor();
        Log.d("MainActivity", "TestScheduledThreadPool");
        //Test1:延迟执行
        /**
         * 第一个参数是Runnable，第二个参数是时间，第三个参数是时间的单位
         */
//        scheduledThreadPool.schedule(new Runnable() {
//            @Override
//            public void run() {
//                Log.d("MainActivity", "TestScheduledThreadPool.run");
//            }
//        }, 3, TimeUnit.SECONDS);

        //Test2:延迟执行，并且周期性执行
        /**
         * 第一个参数是Runnable，第二个参数是延迟时间，第三个参数是巡行间隔，第四个参数是时间的单位
         */
        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                Log.d("MainActivity", "TestScheduledThreadPool.run");
            }
        },2,3,TimeUnit.SECONDS);
    }

    private void TestSingleThreadPool() {
        ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int tmp = i;
            singleThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    Log.d("MainActivity", "Thread Name:" + Thread.currentThread().getName() + " Thread ID:" + Thread.currentThread().getId());
                    Log.d("MainActivity", "i:" + tmp);
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }

    private void TestFixedThreadPool() {
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(2);
        for (int i = 0; i < 10; i++) {
            final int tmp = i;
            fixedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    Log.d("MainActivity", "Thread Name:" + Thread.currentThread().getName() + " Thread ID:" + Thread.currentThread().getId());
                    Log.d("MainActivity", "i:" + tmp);
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }

    private void TestCashedThreadPool() {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            final int tmp = i;
            cachedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    Log.d("MainActivity", "Thread Name:" + Thread.currentThread().getName() + " Thread ID:" + Thread.currentThread().getId());
                    Log.d("MainActivity", "i:" + tmp);
                }
            });
        }
    }
}