多线程--线程池的应用-爱代码爱编程

一 、我们为什么需要使用线程池？

总体来说，线程池有如下的优势：

（1）降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

（2）提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。

（3）提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

二、线程池应用场景介绍

1:网购商品秒杀

2:云盘文件上传和下载

3:12306网上购票系统等

总之

只要有并发的地方、任务数量大或小、每个任务执行时间长或短的都可以使用线程池;

只不过在使用线程池的时候,注意一下设置合理的线程池大小即可;(

三、Java线程池的实现方式

• newCachedThreadPool、

• newFixedThreadPool、

• newSingleThreadExecutor、

• newScheduleThreadPool。

3.1 newCachedThreadPool

创建一个可缓存线程池，如果线程池长度超过处理所需，可灵活回收空闲线程，若线程数不够，则新建线程。

  public void testCache(){
        // 创建一个缓存线程池对象
        ExecutorService cacheThreadPool = Executors.newCachedThreadPool();

        // 通过 for 循环并发多个操作
        for (int i = 0; i < 10; i++){
            final int index = i;
            // 线程的使用  execute 执行
            cacheThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    Log.d("TAG",Thread.currentThread().getName()+" "+index);
                }
            });
        }
    }

运行结果

在线程池2中最高有6个线程在并发

测试线程池长度超过处理所需，可灵活回收空闲线程

实验用例中只有一个线程

  public void testCache(){
        // 创建一个缓存线程池对象
        ExecutorService cacheThreadPool = Executors.newCachedThreadPool();

        // 通过 for 循环并发多个操作
        for (int i = 0; i < 10; i++){
            final int index = i;

            try {                  // 一个任务工作完休息，就不会有多个进程并发
                Thread.sleep(2*1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            // 线程的使用  execute 执行
            cacheThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    Log.d("TAG",Thread.currentThread().getName()+" "+index);
                }
            });
        }
    }

3.2 newFixedThreadPool

创建一个固定大小的线程池。可控制并发的线程数量，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。

public void testFixed(){  // 这种线程池控制的是最大并发数
        // 创建一个缓存线程池对象 但需要告诉他最大并发线程数
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);

        for (int i = 0; i < 10; i++){
            final int index = i;

            // 线程的使用  execute 执行
            fixedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    Log.d("TAG",Thread.currentThread().getName()+" "+index);
                }
            });

        }
    }

运行结果

3.3 newSingleThreadExecutor

创建一个单线程的线程池，即只创建唯一的工作者线程来执行任务，，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

 public void testSingle(){
        ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
        for (int i = 0; i< 10; i++){
            final int index = i;
            singleThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    Log.d("TAG",Thread.currentThread().getName()+" "+ index);
                }
            });
        }
    }

运行结果

3.4 newScheduleThreadPool

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

1. 定时任务 // 定时3秒以后执行

2. 周期任务 // 定时2秒以后执行，每个3秒执行一次

    public void testSchedule(){
        ExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
//        // 定时3秒以后执行
//        ((ScheduledExecutorService) scheduledExecutorService).schedule(new Runnable() {
//            @Override
//            public void run() {
//                Log.d("TAG","delay 3 second");
//            }
//        },3, TimeUnit.SECONDS);

        // 定时2秒以后执行，每个3秒执行一次
        ((ScheduledExecutorService) scheduledExecutorService).scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                Log.d("TAG","delay 2 second,and execute every 3 second");
            }
        },2,3,TimeUnit.SECONDS);
        scheduledExecutorService.shutdown();
    }
}