android常用线程池

public class MainActivity extends AppCompatActivity {

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

        //说明：可以有多个thread pool同时存活，而且各不干预，各自完成任务，根据thread。getname可以看到结果有当前pool是第几个pool和线程号，比如pool-2-thread-1
        //fixedThreadPool 指定线程数量的线程池
        /*该方法返回一个固定线程数量的线程池，该线程池中的线程数量始终不变，即不会再创建新的线程，也不会销毁已经创建好的线程，自始自终都是那几个固定的线程在工作，所以该线程池可以控制线程的最大并发数。
         栗子：假如有一个新任务提交时，线程池中如果有空闲的线程则立即使用空闲线程来处理任务，如果没有，则会把这个新任务存在一个任务队列中，一旦有线程空闲了，则按FIFO方式处理任务队列中的任务。
         打印结果：多个线程任务执行的顺序可能是无序的，而且可以看到当有线程空闲下来的确去执行了其他的需要执行的任务，这个对于那些需要保证按照接收顺序执行的操作是不适用的。比如连续不断的接收到的刷新页面的任务，
         就不应当使用这个方法，很可能出现读取多个任务后，执行的顺序不是顺序的情况。而且每次执行都是以指定的线程数量为基础执行任务数量，比如指定了线程个数是3，那么每次执行就是几个一组几个一组的并发执行*/
        fixedThreadPoolCreate();

        //CachedThreadPool 动态调整线程数量的线程池
        /*作用：该方法返回一个可以根据实际情况调整线程池中线程的数量的线程池。即该线程池中的线程数量不确定，是根据实际情况动态调整的。
        栗子：假如该线程池中的所有线程都正在工作，而此时有新任务提交，那么将会创建新的线程去处理该任务，而此时假如之前有一些线程完成了任务，
        现在又有新任务提交，那么将不会创建新线程去处理，而是复用空闲的线程去处理新任务。那么此时有人有疑问了，那这样来说该线程池的线程岂不是会越集越多？
        其实并不会，因为线程池中的线程都有一个“保持活动时间”的参数，通过配置它，如果线程池中的空闲线程的空闲时间超过该“保存活动时间”则立刻停止该线程，而该线程池默认的“保持活动时间”为60s。也就是说如果
        此时有了空闲的线程，但是没有新的任务来占用，超过一定的时间后就会被销毁了
        打印结果：多个线程执行的顺序肯能还是无序的，而且如果没有空闲的线程，执行速度很快的话，可以看到创建了多个不同的线程在执行操作*/
        cachedThreadPoolCreate();

        //SingleThreadExecutor 只有一个线程的线程池
        /*作用：该方法返回一个只有一个线程的线程池，即每次只能执行一个线程任务，多余的任务会保存到一个任务队列中，等待这一个线程空闲，当这个线程空闲了再按FIFO方式顺序执行任务队列中的任务。这个就可以保证是顺序执行的
        打印结果：可以看到threadname中始终是一个线程在存活，而且这个线程在顺序执行多个任务*/
        singleThreadPoolCreate();

        //ScheduledThreadPool 可以控制线程池内线程定时或周期性执行某任务的线程池
        /*可以指定线程池中的线程数量，而且可以指定比如延迟多长时间执行任务，或者每隔多长时间执行一次该任务, 这里说的每隔多长时间执行一次任务指的是可以永远循环执行下去，比如2秒执行一次，完成后再2秒执行一次，
        * 而且可以是多个线程执行任务*/
        scheduledThreadPoolCreate();

        //SingleThreadScheduledExecutor 可以控制线程池内线程定时或周期性执行某任务的线程池， 线程池大小为1
        /*这类的线程池和ScheduledThreadPool没有太大的区别，唯一的区别是线程只有一个*/
        singleScheduledThreadPoolCreate();
    }

    void fixedThreadPoolCreate() {
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        for (int i = 1; i <= 10; i++) {
            final int index = i;
            fixedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    String threadName = Thread.currentThread().getName();
                    Log.d("Thread", "--- fixedThread 线程 : " + threadName + ", 正在执行第 " + index + "  个任务");
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }

    void cachedThreadPoolCreate() {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i <= 10; i++) {
            final int index = i;
            cachedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    String threadName = Thread.currentThread().getName();
                    Log.d("Thread", "--- cachedThreadPool线程 : " + threadName + ", 正在执行第 " + index + "  个任务");
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }

    void singleThreadPoolCreate() {
        ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
        for (int i = 0; i <= 10; i++) {
            final int index = i;
            singleThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    String threadName = Thread.currentThread().getName();
                    Log.d("Thread", " --- singleThreadPool : " + threadName + ", 正在执行第 " + index + "  个任务");
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }

    void scheduledThreadPoolCreate() {
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
        for (int i = 0; i <= 10; i++) {
            final int index = i;
            //延迟5秒后才会执行任务，一次性执行完任务
            scheduledThreadPool.schedule(new Runnable() {
                @Override
                public void run() {
                    String threadName = Thread.currentThread().getName();
                    Log.d("Thread", " --- scheduledThreadPool : " + threadName + ", 正在执行第 " + index + "  个任务");
                }
            }, 5, TimeUnit.SECONDS);

            //延迟1秒后每隔2秒执行一次任务
            scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {
                    String threadName = Thread.currentThread().getName();
                    Log.d("Thread", " --- scheduledThreadPool with duration : " + threadName + ", 正在执行第 " + index + "  个任务");
                }
            }, 1, 2, TimeUnit.SECONDS);
        }
    }

    void singleScheduledThreadPoolCreate() {
        ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
        for (int i = 0; i <= 10; i++) {
            final int index = i;
            scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {
                    String threadName = Thread.currentThread().getName();
                    Log.d("Thread", " --- SingleScheduledThreadPool with duration : " + threadName + ", 正在执行第 " + index + "  个任务");
                }
            }, 1, 2, TimeUnit.SECONDS);

        }

    }

}