java四种线程池（基本使用）

标题java四种线程池及使用示例

1、线程工厂

1、我们先来写ThreadFactory，在创建线程池时候可以传入自定义的线程工厂，线程工厂说白了就是用来定制线程的一些属性：名字、优先级、是否为守护线程。直接看代码即可。

当然创建线程池的时候可以不传入自定义线程工厂。

public class MyThreadFactory implements ThreadFactory {
    private static final String thread_prefix = "self_thread";

    private AtomicInteger integer = new AtomicInteger(0);

    private String threadName = null;

    public MyThreadFactory(String threadName) {
        this.threadName = threadName;
    }

    public MyThreadFactory() {
    }

    @Override
    public Thread newThread(Runnable r) {
        Thread thread = new Thread(r);
        String name = threadName == null ? thread_prefix + " " + integer.getAndIncrement() : threadName + " " + integer.getAndIncrement();
        thread.setName(name);

        return thread;
    }
}

2、我们来详细看一下四种线程池

单一线程的线程池	可缓存的线程池	可周期性执行的线程池	固定数目的线程池
.newSingleThreadExecutor	.newCachedThreadPool	.newScheduledThreadPool	.newFixedThreadPool

1、单一线程的线程池：

此线程池只有一个线程，用仅有的一个线程来执行任务，保证所有的任务按照指定顺序（FIFO，LIFO，优先级）执行，所有的任务都保存在队列LinkedBlockingQueue中，等待唯一的单线程来执行任务。

    private static final Object lock = new Object();
    private static int count = 0;
   

private static void testSingleThreadThreadPool() {
        ExecutorService service = Executors.newSingleThreadExecutor(new MyThreadFactory("singleThread"));
        for (int i = 0; i < 6; i++) {
            test(service);
        }
    }


    private static void test(ExecutorService service) {
        synchronized (lock) {
            count++;
            System.out.println(Thread.currentThread().getName());

            if (count == 5) {
                System.out.println("count == 5 shutdown ");
                service.shutdown();
            }
        }
    }

可以从输出看到，只new了一个线程。

2、可缓存的线程池

创建一个可缓存的无界线程池，如果线程池长度超过处理需要，可灵活回收空线程，若无可回收，则新建线程。当线程池中的线程空闲时间超过60s，则会自动回收该线程，当任务超过线程池的线程数则创建新的线程，线程池的大小上限为Integer.MAX_VALUE,可看作无限大。

   private static void testCachedThreadPool() {
        ExecutorService service = Executors.newCachedThreadPool(new MyThreadFactory("cached"));
        for (int i = 0; i < 1000; i++) { // 循环数稍微大一点 模拟线程回收后被复用
            service.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()); // 可从控制台看出相同线程名的线程
                }
            });
        }
    }

3、可周期性执行的线程池

    private static void testScheduleThreadPool() {
        /**
         * 可周期性执行的线程池 延迟2秒执行 每间隔4秒执行一次
         *
         * 是“以固定的频率”执行，period（周期）指的是两次成功执行之间的时间。
         * 上一个任务开始的时间计时，一个period后，检测上一个任务是否执行完毕，
         * 如果上一个任务执行完毕，则当前任务立即执行，如果上一个任务没有执行完毕，
         * 则需要等上一个任务执行完毕后立即执行。
         */
        ExecutorService service = Executors.newScheduledThreadPool(6, new MyThreadFactory());
        ((ScheduledExecutorService) service).scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                test(service);
            }
        }, 2, 4, TimeUnit.SECONDS);

        // 定时  执行一次   的任务，延迟1s后执行
        ((ScheduledExecutorService) service).schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + ", delay 1s");

            }
        }, 1, TimeUnit.SECONDS);


        /**
         * “以固定的延时”执行，delay（延时）指的是一次执行终止和下一次执行开始之间的延迟。
         */
        ((ScheduledExecutorService) service).scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                long start = new Date().getTime();
                System.out.println("scheduleWithFixedDelay 开始执行时间:" +
                        DateFormat.getTimeInstance().format(new Date()));
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                long end = new Date().getTime();
                System.out.println("scheduleWithFixedDelay执行花费时间=" + (end - start) / 1000 + "m");
                System.out.println("scheduleWithFixedDelay执行完成时间："
                        + DateFormat.getTimeInstance().format(new Date()));
                System.out.println();
                System.out.println();
            }
        }, 2, 3, TimeUnit.SECONDS);

    }

4、固定数目的线程池

这个就很好理解了。固定数量的线程。

    /**
     * 固定数量的线程池
     */
    private static void testFixedThreadPool() {
        ExecutorService service = Executors.newFixedThreadPool(5, new MyThreadFactory());
        for (int i = 0; i < 8; i++) {
            service.submit(new Runnable() {
                @Override
                public void run() {
                    test(service);
                }
            });
        }
    }

5、方法对比