java线程池的四种创建方式

◆创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。newCachedThreadPool
◆创建一个定长的线程池，可控制线程最大并发数，超出的线程会在队列中等待。newFixedThreadPool
◆创建一个定长线程池，支持定时及周期性任务执行。延迟执行newScheduledThreadPool
◆创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序执行newSingleThreadExecutor
其实这四种方法的实现 都是 new 了一个 ThreadPoolExecutor出来！
1.创建一个缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，代码如下：

    private void cachedThread() {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            cachedThreadPool.execute(new Runnable() {
                public void run() {
                    System.out.println(index);
                }
            });
        }
    }

2.创建一个定长线程池，控制最大并发数，如果超过的线程会在队列中等待。代码如下：

private  void fixedThread() {
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        fixedThreadPool.execute(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 15; i++) {
                    System.out.println("A" + "===" + i);
                }
            }
        });
        fixedThreadPool.execute(new Runnable() {

            @Override
            public void run() {
                for (int i = 0; i < 15; i++) {
                    System.out.println("B" + "===" + i);
                }
            }
        });
        fixedThreadPool.execute(new Runnable() {

            @Override
            public void run() {
                for (int i = 0; i < 15; i++) {
                    System.out.println("C" + "===" + i);
                }
            }
        });
        fixedThreadPool.execute(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 15; i++) {
                    System.out.println("D" + "===" + i);
                }
            }
        });
    }

3，创建一个定长线程池，可以设置定时及周期性任务执行。延迟执行，代码如下：

private void scheduledThreadPool(){
        ScheduledExecutorService scheduledThreadPool=Executors.newScheduledThreadPool(3);
        System.out.println(System.currentTimeMillis());
        //参数一 执行队形，参数二  执行周期       参数三：时间单位 此方法是隔多长时间执行一次
        scheduledThreadPool.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(System.currentTimeMillis());
                System.out.println("延迟三秒执行");
            }
        }, 3, TimeUnit.SECONDS);
        System.out.println(System.currentTimeMillis());
    //此方法是多长时间后执行一次，然后每隔多长时间执行一次 参数一 执行队形，参数二 隔多长时间后执行线程 参数三 执行周期参数四:时间单位
        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(System.currentTimeMillis());
                System.out.println("延迟执行");
            }
        }, 1, 4, TimeUnit.SECONDS);
    }

4，创建一个单线程的线程池，但是保证所有要执行的任务是有序的，代码如下:

private void singleThreadExecutor(){
        ExecutorService sigleThreadExecutor=Executors.newSingleThreadExecutor();
        sigleThreadExecutor.execute(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("我是第一个");
                }
            }
        });
        sigleThreadExecutor.execute(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("我是第2个");
                }
            }
        });
        sigleThreadExecutor.execute(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("我是第3个");
                }
            }
        });
    }