Java四种线程池的使用

Java通过Executors提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

 

  创建一个可缓存的线程
//        ExecutorService CachedPool = Executors.newCachedThreadPool();
//
//        for (int i=0;i<1000;i++){
//            final int index=i;
//
//            try {
//                Thread.sleep(index*10);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
       给线程池添加任务
//            CachedPool.execute(new Runnable() {
//                @Override
//                public void run() {
//                    Log.i("打印编号",""+index);
//                }
//            });
//        }
//    }
//}

线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。
 
(2) newFixedThreadPool
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。示例代码如下：

因为线程池大小为3，每个任务输出index后sleep 2秒，所以每两秒打印3个数字。
定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()

 

(3)  newScheduledThreadPool
创建一个定长线程池，支持定时及周期性任务执行。延迟执行示例代码如下：

 ExecutorService fixedThreadPool=Executors.newFixedThreadPool(6);
//
//        for (int i=0;i<1000;i++){
//            final  int index =i;
//
//            fixedThreadPool.execute(new Runnable() {
//                @Override
//                public void run() {
//                    try {
//                        Thread.sleep(index  *1000);
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }
//                    Log.i("打印数据"," "+index);
//                }
//            });

表示延迟3秒执行。

定期执行示例代码如下：

 ExecutorService singlepool =Executors.newSingleThreadExecutor();
//        for (int i=0;i<10;i++){
//            final int index =i;
//            singlepool.execute(new Runnable() {
//                @Override
//                public void run() {
//                    try {
//                        Thread.sleep(2000);
//                        Log.i("数据打印",""+index);
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }
//                }
//            });
//        }

表示延迟1秒后每3秒执行一次。

 

(4) newSingleThreadExecutor
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。示例代码如下：

  ScheduledExecutorService schemedPool =Executors.newScheduledThreadPool(5);

延时操作，第一个参数是要操作的任务，第二个参数是要延迟的时间，第三个延迟的时间的单位（ },3, TimeUnit.SECONDS);）
        schemedPool.schedule(new Runnable() {
            @Override
            public void run() {
             Log.i("打印","任务执行完毕");
            }
        },3, TimeUnit.SECONDS);


       定时周期性任务
        第一个参数要执行的任务，
        第二个参数是延迟多长时间
        第三个参数是周期时间（每隔多长时间触发一次）
       第四次参数是时间的单位
        schemedPool.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                Log.i("打印","我在执行中");
            }
        },1,5,TimeUnit.SECONDS);
    }
}