Java线程池系列（一）：简单介绍及示例

系列导航

(一) 简单介绍及示例
(二)获取线程的返回结果

简单介绍及示例

一、使用介绍

线程可以通过Thread类一次创建一个线程，同时进行管理。但是这种方式常用于对线程很大程度的介入管理，比如控制优先级、对线程进行标识然后进行维护、创建的线程需要保持很长时间的运行等。而在实际使用中，我们常常可以把线程交给线程池来管理，这样不仅方便管理，而且很多时候能够提升性能，比如：不频繁销毁线程，重复执行任务。

二、线程池的类型

Java中提供了四种很方便的线程池创建方式，它们都会返回一个已经封装完善的ThreadPoolExecutor。

1. newCachedThreadPool：创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。线程池为无限大，当执行第二个任务时第一个任务也已经完成的话，会复用执行第一个任务的线程，而不用每次新建线程。
   
   
2. newFixedThreadPool：创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
   
   
3. newScheduledThreadPool：创建一个定长线程池，支持定时及周期性任务执行。
   
   
4. newSingleThreadExecutor：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序执行。

三、示例

1、newCachedThreadPool

/*
 * newCachedThreadPool
 * 1、用来创建一个可以无限扩大的线程池，适用于负载较轻的场景，执行短期异步任务。
 * 2、可灵活回收空闲线程，若无可回收，则新建线程。
 * 3、线程池为无限大，当执行第二个任务时第一个任务也已经完成的话，会复用执行第一个任务的线程，而不用每次新建线程。
 *
 * */
public class CachedThreadPoolTest {
    public static void main(String[] args) {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 100; i++) {
            cachedThreadPool.execute(new Runnable() {
                public void run() {
                    Thread.currentThread().setName("测试线程");
                    System.out.println("------------" + Thread.currentThread().getName() + " : " + Thread.currentThread().getId());
                }
            });
        }
        cachedThreadPool.shutdown();
    }
}

2、newFixedThreadPool

/*
* 1、创建一个固定大小的线程池，因为采用无界的阻塞队列，所以实际线程数量永远不会变化，适用于负载较重的场景，对当前线程数量进行限制。
* 2、保证线程数可控，超出的线程会在队列中等待，所以不会造成线程过多，导致系统负载更为严重。
*
* */
public class FixedThreadPoolTest {
    public static void main(String[] args) {
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {
            fixedThreadPool.execute(new Runnable() {
                public void run() {
                    Thread.currentThread().setName("测试线程");
                    System.out.println("------------" + Thread.currentThread().getName() + " : " + Thread.currentThread().getId());
                }
            });
        }
        fixedThreadPool.shutdown();
    }
}

3、newScheduledThreadPool

/*
* 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序。
*
* */
public class SingleThreadPoolTest {
    public static void main(String[] args) {
        ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 5; i++) {
            singleThreadPool.execute(new Runnable() {
                public void run() {
                    Thread.currentThread().setName("测试线程");
                    System.out.println("------------" + Thread.currentThread().getName() + " : " + Thread.currentThread().getId());
                }
            });
        }
        singleThreadPool.shutdown();
    }
}

4、newSingleThreadExecutor

/*
 * 创建一个周期线程池，支持定时及周期性任务执行(可用于执行延迟的任务)。
 *
 * */
public class ScheduledThreadPoolTest {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        //创建线程，延迟5秒执行
//        scheduledThreadPool.schedule(new Runnable() {
//            public void run() {
//                Thread.currentThread().setName("测试线程");
//                System.out.println("------------" + Thread.currentThread().getName() + " : " + Thread.currentThread().getId());
//            }
//        }, 5, TimeUnit.SECONDS);
//        scheduledThreadPool.shutdown();


        //创建线程，延迟5秒执行，并每隔2秒执行一次
        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
            public void run() {
                Thread.currentThread().setName("测试线程");
                System.out.println("------------" + Thread.currentThread().getName() + " : " + Thread.currentThread().getId());
            }
        }, 3, 2, TimeUnit.SECONDS);
        //这里注释掉，否则会关闭线程
//        scheduledThreadPool.shutdown();
    }
}