JAVA并发编程：详解Executors工厂创建线程池的5种方法

最新推荐文章于 2024-04-20 22:45:48 发布
最新推荐文章于 2024-04-20 22:45:48 发布
阅读量430 收藏 1
点赞数
分类专栏： Java 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lspj201007186/article/details/109276668
版权

  上一篇我们详细讲解了线程池的工作原理及其基本的应用，本文主要讲解一下如何使用Executors工厂创建线程池的5种方法，在JDK1.7中只提供了4种方法（前面4种），而在JDK1.8中新增了一种方法，详细请见下文第五种方式。

1、创建固定线程数线程池

  创建固定线程数的线程池一共有两个方法，分别如下所示：

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>(),
                                  threadFactory);
}

  核心线程数corePoolSize等于最大线程数maximumPoolSize，没有空闲线程数，因此空闲线程的存活时间keepAliveTime设置为0，使用LinkedBlockingQueue有界队列作为线程池的工作队列（也可以认为是无界队列，存放任意个任务），队列大小为Integer.MAX_VALUE。
  适用于为了满足资源管理的需求，需要限制当前线程数量的应用场景，它适用于负载比较重的服务器，任务量已知，相对耗时的任务。

package com.enjoy.lspj.threadpool;

import java.text.SimpleDateFormat;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Executors工厂类
 * <p>
 * 创建固定线程数的线程池:
 * 核心线程数corePoolSize等于最大线程数maximumPoolSize，没有空闲线程数，因此线程的存活时间keepAliveTime设置为0，
 * 使用LinkedBlockingQueue有界队列作为线程池的工作队列（也可以认为是无界队列，存放任意个任务），队列大小为Integer.MAX_VALUE。
 * <p>
 * 适用于为了满足资源管理的需求，需要限制当前线程数量的应用场景，它适用于负载比较重的服务器，任务量已知，相对耗时的任务。
 */
public class UseExecutorsCreateThreadPool1 {
    final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
    private static AtomicInteger count = new AtomicInteger();
    private static ExecutorService executorService = Executors.newFixedThreadPool(2, (r) -> {
        return new Thread(r, "t" + count.incrementAndGet());
    });


    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            int finalI = i;
            executorService.execute(() -> {
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(getSystemTime() + " 线程" + Thread.currentThread().getName() + " 执行任务" + finalI);
            });
        }

    }

    private static String getSystemTime() {
        return sdf.format(System.currentTimeMillis());
    }
}

执行结果如下：
在这里插入图片描述
  从执行结果来看，无论主线程提交多少个任务，线程池最多会创建两个线程来执行提交的所有任务。

2、创建单个线程数的线程池

  创建单个线程数的线程池一共有两个方法，分别如下所示：

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>(),
                                threadFactory));
}

  核心线程数corePoolSize等于最大线程数maximumPoolSize，没有空闲线程数，因此空闲线程的存活时间keepAliveTime设置为0，使用LinkedBlockingQueue有界队列作为线程池的工作队列（也可以认为是无界队列），队列大小为Integer.MAX_VALUE。
  适用于多个任务排队有序执行，线程池中线程数固定为1，当提交的任务数大于1时，会放入阻塞队列中。区别于使用 new Thread() 创建一个单线程串行执行任务，如果创建的单线程执行任务失败而线程终止，那么后续的执行任务没有任何的补救措施，无法执行；如果使用线程池创建的线程执行任务失败而终止，线程池会再创建一个线程来执行任务，来保证线程池的正常工作。

package com.enjoy.lspj.threadpool;

import java.text.SimpleDateFormat;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Executors工厂类
 * <p>
 * 创建单个线程数的线程池:
 * 核心线程数corePoolSize等于最大线程数maximumPoolSize，没有空闲线程数，因此线程的存活时间keepAliveTime设置为0，
 * 使用LinkedBlockingQueue有界队列作为线程池的工作队列（也可以认为是无界队列），队列大小为Integer.MAX_VALUE。
 * <p>
 * 适用于多个任务排队有序执行，线程池中线程数固定为1，当提交的任务数大于1时，会放入阻塞队列中。
 * 区别于使用 new Thread() 创建一个单线程串行执行任务，如果创建的单线程执行任务失败而线程终止，那么后续的执行任务没有任何的补救措施，无法执行；
 * 如果使用线程池创建的线程执行任务失败而终止，线程池会再创建一个线程来执行任务，来保证线程池的正常工作。
 */
public class UseExecutorsCreateThreadPool2 {
    final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
    private static AtomicInteger count = new AtomicInteger();
    private static ExecutorService executorService = Executors.newSingleThreadExecutor((r) -> {
        return new Thread(r, "t" + count.incrementAndGet());
    });


    /**
     * 所有任务都由一个线程 t1 来执行
     */
    private static void m1(){
        for (int i = 0; i < 5; i++) {
            int finalI = i;
            executorService.execute(() -> {
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(getSystemTime() + " 线程" + Thread.currentThread().getName() + " 执行任务" + finalI);
            });
        }
    }

    /**
     * 线程池中的线程如果在执行任务的时候抛出异常，线程池会再重新创建一个线程来执行任务。
     */
    private static void m2(){

        executorService.execute(() -> {
            System.out.println(getSystemTime() + " 线程" + Thread.currentThread().getName() + " 执行任务开始");
            int a = 1/0;
            System.out.println(getSystemTime() + " 线程" + Thread.currentThread().getName() + " 执行任务结束");
        });

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        executorService.execute(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(getSystemTime() + " 线程" + Thread.currentThread().getName() + " 执行任务");
        });

    }

    /**
     * new Thread() 创建一个单线程串行执行任务，如果创建的单线程执行任务失败而线程终止，那么后续的执行任务没有任何的补救措施，无法执行。
     */
    private static void m3(){

        new Thread(()->{
            System.out.println(getSystemTime() + " 线程" + Thread.currentThread().getName() + " 执行任务开始");
            int a = 1/0;
            System.out.println(getSystemTime() + " 线程" + Thread.currentThread().getName() + " 执行任务结束");
        },"t").start();




    }

    public static void main(String[] args) throws InterruptedException {
        //m1();
        //m2();
        m3();
    }


    private static String getSystemTime() {
        return sdf.format(System.currentTimeMillis());
    }
}

方法m1()执行结果如下：
在这里插入图片描述
  从执行结果可知，所有任务都由一个线程 t1 来执行。

方法m2()执行结果如下：
在这里插入图片描述
  从执行结果可知，线程池中的线程 t1 如果在执行任务的时候抛出异常，线程池会再重新创建一个线程 t2 来执行任务。

方法m3()执行结果如下：
在这里插入图片描述
  从执行结果可知，new Thread() 创建一个单线程串行执行任务，如果创建的单线程执行任务失败而线程终止，那么后续的执行任务没有任何的补救措施，无法执行。

与上面说的第一种方式创建线程池相比，二者区别在于：

  • Executors.newSingleThreadExecutor() 线程个数始终为1，不能修改；
  • Executors.newFixedThreadPool(1) 初始时为1，以后还可以修改，对外暴露的是 ThreadPoolExecutor 对象，可以强转后调用 setCorePoolSize(int corePoolSize) 方法进行修改线程池数量；

3、创建可缓存线程的线程池

  创建可缓存线程的线程池一共有两个方法，分别如下所示：

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>(),
                                  threadFactory);
}

  核心线程数 corePoolSize 等于0，最大线程数 maximumPoolSize 等于Integer.MAX_VALUE，这里把 keepAliveTime 设置为60s，意味着 CachedThreadPool 中的空闲线程等待新任务的最长时间为60s，空闲线程超过60s后将会被销毁。
  一个可根据需要创建新线程的线程池，如果现有线程没有可用的，则创建一个新线程并添加到池中，如果有被使用完但是还没销毁的线程，就复用该线程；如果缓存中有60s未被使用的线程，则被销毁。因此，长时间保持空闲的线程池不会使用任何资源，这种线程池比较灵活，适用于执行很多短期异步任务的程序或者负载较轻的服务器，这些线程池通常可提高程序性能。
  该线程池使用 SynchronousQueue 作为工作队列，它是一个同步阻塞队列，SynchronousQueue 队列中没有任何内部容量，甚至连一个容量都没有。主线程提交的任务放到 SynchronousQueue 队列中，需要有线程取走任务后才能往队列中放下一个任务。

  接下来分析一下 SynchronousQueue 队列的基本使用，详见下面代码示例。

package com.enjoy.lspj.threadpool;

import java.text.SimpleDateFormat;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;

/**
 *
 * 同步阻塞队列：
 * SynchronousQueue 队列中没有任何内部容量，甚至连一个容量都没有。提交的任务放到 SynchronousQueue 队列中，
 * 需要有线程取走任务后才能往队列中放下一个任务。
 *
 */
public class UseSynchronousQueue {
    final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
    private static SynchronousQueue<String> synchronousQueue = new SynchronousQueue();

    public static void main(String[] args) throws InterruptedException {

        new Thread(()->{
            try {
                System.out.println(getSystemTime() + " 线程 " + Thread.currentThread().getName() + " begin put 第一个元素");
                synchronousQueue.put("one");
                System.out.println(getSystemTime() + " 线程 " + Thread.currentThread().getName() + " end put 第一个元素");

                System.out.println(getSystemTime() + " 线程 " + Thread.currentThread().getName() + " begin put 第二个元素");
                synchronousQueue.put("two");
                System.out.println(getSystemTime() + " 线程 " + Thread.currentThread().getName() + " end put 第二个元素");

                System.out.println(getSystemTime() + " 线程 " + Thread.currentThread().getName() + " begin put 第三个元素");
                synchronousQueue.put("three");
                System.out.println(getSystemTime() + " 线程 " + Thread.currentThread().getName() + " end put 第三个元素");

            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        },"t1").start();


        TimeUnit.SECONDS.sleep(5);

        new Thread(()->{
            try {
                System.out.println(getSystemTime() + " 线程 " + Thread.currentThread().getName() + " begin take 第一个元素");
                synchronousQueue.take();
                System.out.println(getSystemTime() + " 线程 " + Thread.currentThread().getName() + " end take 第一个元素");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        },"t2").start();
    }

    private static String getSystemTime() {
        return sdf.format(System.currentTimeMillis());
    }
}

执行结果如下：
在这里插入图片描述
  从执行结果来看，SynchronousQueue 同步队列中已经存放了一个任务，如果没有线程从队列中取走任务，那么后面的任务是不能放到队列中的。示例当中线程 t1 put 了一个任务，5秒后线程 t2 从队列中取走了任务，线程 t1 才可以往队列中放第二个任务。

  如果主线程提交任务的速度高于线程池中线程处理任务的速度时，线程池会不断创建新的线程。极端情况下，线程池会因为创建过多线程而耗尽CPU和内存资源。因此，该线程池比较适用于执行很多短期异步任务。

package com.enjoy.lspj.threadpool;

import java.text.SimpleDateFormat;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Executors工厂类
 * <p>
 * 创建可缓存线程的线程池:
 * 核心线程数corePoolSize等于0，最大线程数maximumPoolSize等于Integer.MAX_VALUE，这里把keepAliveTime设置为60s，
 * 意味着CachedThreadPool中的空闲线程等待新任务的最长时间为60s，空闲线程超过60s后将会被销毁。
 * <p>
 * 一个可根据需要创建新线程的线程池，如果现有线程没有可用的，则创建一个新线程并添加到池中，
 * 如果有被使用完但是还没销毁的线程，就复用该线程；如果缓存中有60s未被使用的线程，则被销毁。
 * 因此，长时间保持空闲的线程池不会使用任何资源，这种线程池比较灵活，适用于执行很多短期异步任务的程序或者负载较轻的服务器，
 * 这些线程池通常可提高程序性能。
 * <p>
 * 该线程池使用 SynchronousQueue 作为工作队列，它是一个同步阻塞队列，SynchronousQueue 队列中没有任何内部容量，
 * 甚至连一个容量都没有。主线程提交的任务放到 SynchronousQueue 队列中，需要有线程取走任务后才能往队列中放下一个任务。
 */
public class UseExecutorsCreateThreadPool3 {
    final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
    private static AtomicInteger count = new AtomicInteger();
    private static ExecutorService executorService = Executors.newCachedThreadPool((r) -> {
        return new Thread(r, "t" + count.incrementAndGet());
    });


    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 5; i++) {
            int finalI = i;
            executorService.execute(() -> {
                System.out.println(getSystemTime() + " 线程" + Thread.currentThread().getName() + " 执行任务" + finalI);
            });
        }

        TimeUnit.SECONDS.sleep(1);
        System.out.println("============================== 线程池中的线程未超时，继续使用缓存中的线程执行任务 ================================");

        for (int i = 5; i < 10; i++) {
            int finalI = i;
            executorService.execute(() -> {
                System.out.println(getSystemTime() + " 线程" + Thread.currentThread().getName() + " 执行任务" + finalI);
            });
        }

        TimeUnit.SECONDS.sleep(65); // 睡眠65s，之前线程池中的空闲线程足够到达了超时时间。
        System.out.println("============================== 65s 后之前线程池中创建的线程已经超时被销毁，需要重新创建线程执行任务 ================================");
        for (int i = 10; i < 15; i++) {
            int finalI = i;
            executorService.execute(() -> {
                System.out.println(getSystemTime() + " 线程" + Thread.currentThread().getName() + " 执行任务" + finalI);
            });
        }
    }

    private static String getSystemTime() {
        return sdf.format(System.currentTimeMillis());
    }
}

执行结果如下：
在这里插入图片描述
  从执行结果来看，线程池一共提交了15个任务，第0 ~ 4的5个任务分别创建了5个线程来执行；主线程 sleep 1秒后继续提交第5 ~ 9的5个任务，由于线程池中缓存的线程还未被销毁，因此继续使用缓存中的线程执行任务；主线程 sleep 65秒后继续提交第10 ~ 14的5个任务，65s 后之前线程池中创建的线程已经超时被销毁，需要重新创建线程执行任务；

4、创建定时执行任务的线程池

  创建一个线程池，该线程池可以在定期或者给定的延迟时间后执行任务。 Executors 可以创建 2 种类型的 ScheduledThreadPoolExecutor。

  • SingleThreadScheduledExecutor。只创建一个线程的ScheduledThreadPoolExecutor。适用于需要单个后台线程执行周期任务，同时需要保证顺序地执行各个任务的应用场景。
  • ScheduledThreadPoolExecutor。创建若干个线程的ScheduledThreadPoolExecutor。适用于需要多个后台线程执行周期任务，同时为了满足资源管理的需求而需要限制后台线程的数量的应用场景。

演示第一种方式创建线程池的基本应用

package com.enjoy.lspj.threadpool;

import java.text.SimpleDateFormat;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Executors工厂类
 * <p>
 * 创建定时执行任务的线程池:
 * 创建一个线程池，该线程池可以在定期或者给定的延迟时间后执行任务。Executors 可以创建 2 种类型的 ScheduledThreadPoolExecutor。
 * <p>
 * 1、SingleThreadScheduledExecutor。只创建一个线程的ScheduledThreadPoolExecutor。
 * 适用于需要单个后台线程执行周期任务，同时需要保证顺序地执行各个任务的应用场景。
 * 2、ScheduledThreadPoolExecutor。创建若干个线程的 ScheduledThreadPoolExecutor。
 * 适用于需要多个后台线程执行周期任务，同时为了满足资源管理的需求而需要限制后台线程的数量的应用场景。
 * <p>
 * 演示第一种方式创建线程池的基本应用
 */
public class UseExecutorsCreateThreadPool4 {
    final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
    private static AtomicInteger count = new AtomicInteger();
    private static ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor((r) -> {
        return new Thread(r, "t" + count.incrementAndGet());
    });


    /**
     * 延迟 delay 个 unit 时间后执行（延迟5秒后执行，只执行一次任务）
     */
    private static void m1() {
        System.out.println(getSystemTime() + " 线程" + Thread.currentThread().getName() + " 执行任务");
        // 延迟 delay 个 unit 时间后执行（延迟5秒后执行，只执行一次任务）
        scheduledExecutorService.schedule(() -> {
            System.out.println(getSystemTime() + " 线程" + Thread.currentThread().getName() + " 执行任务");
        }, 5, TimeUnit.SECONDS);
    }

    /**
     * 周期性执行任务，延迟4秒后开始执行任务，隔2秒执行一次任务。
     * <p>
     * 创建并执行一个周期行任务，该任务在给定的初始延迟后第一次执行，随后在给定的周期内执行;
     * 如果任务的任何执行遇到异常，则禁止后续执行。否则，任务将仅通过执行程序的取消或终止而终止。
     * 如果该任务的任何执行时间超过了它的周期，那么后续执行可能会延迟开始，但不会并发执行。
     */
    private static void m2() {
        System.out.println(getSystemTime() + " 线程" + Thread.currentThread().getName() + " 执行任务");
        scheduledExecutorService.scheduleAtFixedRate(() -> {
            System.out.println(getSystemTime() + " 线程" + Thread.currentThread().getName() + " 执行任务开始");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(getSystemTime() + " 线程" + Thread.currentThread().getName() + " 执行任务结束。。。");
        }, 4, 2, TimeUnit.SECONDS);
    }

    /**
     * 创建并执行一个周期性操作，该操作在给定的初始延迟之后首先启用，然后在一个执行的终止和下一个执行的开始之间使用给定的延迟。
     * 如果任务的任何执行遇到异常，则禁止后续执行。否则，任务将仅通过执行程序的取消或终止而终止。
     * 如果该任务的任何执行时间超过了它的周期，那么后续执行会在前一个任务执行结束后间隔delay后开始，但不会并发执行。
     */
    private static void m3(){
        System.out.println(getSystemTime() + " 线程" + Thread.currentThread().getName() + " 执行任务");
        scheduledExecutorService.scheduleWithFixedDelay(()->{
            System.out.println(getSystemTime() + " 线程" + Thread.currentThread().getName() + " 执行任务开始");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(getSystemTime() + " 线程" + Thread.currentThread().getName() + " 执行任务结束。。。");
        },2,2,TimeUnit.SECONDS);
    }

    public static void main(String[] args) throws InterruptedException {
        m1();
        //m2();
        //m3();
    }

    private static String getSystemTime() {
        return sdf.format(System.currentTimeMillis());
    }
}

方法m1()执行结果如下：
在这里插入图片描述
  从执行结果来看，main 线程在执行任务后提交一个任务给线程池，延迟5秒后执行，且只执行一次任务。

方法m2()执行结果如下：
在这里插入图片描述
  从执行结果来看，main 线程在执行任务后提交一个任务给线程池，延迟4秒后开始执行任务，隔2秒执行一次任务。创建并执行一个周期性任务，该任务在给定的初始延迟后第一次执行，随后在给定的周期内执行。如果该任务的任何执行时间超过了它的周期，那么后续执行可能会延迟开始，但不会并发执行。示例中的任务执行时长明细大于周期时长，不会按照设定的隔两秒执行一次任务，这种情况下一周期任务会延迟执行，且在上一个周期任务执行结束后立刻开始执行。

方法m3()执行结果如下：
在这里插入图片描述
  从执行结果来看，main 线程在执行任务后提交一个任务给线程池，延迟2秒后开始执行任务，隔2秒执行一次任务。创建并执行一个周期性操作，该操作在给定的初始延迟之后首先启用，然后在一个执行的终止和下一个执行的开始之间使用给定的延迟。如果该任务的任何执行时间超过了它的周期，那么后续执行会在前一个任务执行结束后间隔delay后开始，但不会并发执行。示例中的任务执行时长明细大于周期时长，不会按照设定的隔两秒执行一次任务，这种情况下一周期任务会延迟执行，且在上一个周期任务执行结束后隔2秒开始执行，这也是跟方法 m2() 执行结果的区别所在之处。

演示第二种方式创建线程池的基本应用，定义核心线程数为2，线程池会创建多个线程来执行任务。

package com.enjoy.lspj.threadpool;

import java.text.SimpleDateFormat;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Executors工厂类
 * <p>
 * 创建定时执行任务的线程池:
 * 创建一个线程池，该线程池可以在定期或者给定的延迟时间后执行任务。Executors 可以创建 2 种类型的 ScheduledThreadPoolExecutor。
 * <p>
 * 1、SingleThreadScheduledExecutor。只创建一个线程的ScheduledThreadPoolExecutor。
 * 适用于需要单个后台线程执行周期任务，同时需要保证顺序地执行各个任务的应用场景。
 * 2、ScheduledThreadPoolExecutor。创建若干个线程的 ScheduledThreadPoolExecutor。
 * 适用于需要多个后台线程执行周期任务，同时为了满足资源管理的需求而需要限制后台线程的数量的应用场景。
 * <p>
 * 演示第二种方式创建线程池的基本应用，定义核心线程数为2，线程池会创建多个线程来执行任务。
 */
public class UseExecutorsCreateThreadPool5 {
    final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
    private static AtomicInteger count = new AtomicInteger();
    private static ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2,(r) -> {
        return new Thread(r, "t" + count.incrementAndGet());
    });


    /**
     * 延迟 delay 个 unit 时间后执行（延迟5秒后执行，只执行一次任务）
     */
    private static void m1() {
        System.out.println(getSystemTime() + " 线程" + Thread.currentThread().getName() + " 执行任务");
        // 延迟 delay 个 unit 时间后执行（延迟5秒后执行，只执行一次任务）
        scheduledExecutorService.schedule(() -> {
            System.out.println(getSystemTime() + " 线程" + Thread.currentThread().getName() + " 执行任务");
        }, 5, TimeUnit.SECONDS);
    }

    /**
     * 周期性执行任务，延迟4秒后开始执行任务，隔2秒执行一次任务。
     * <p>
     * 创建并执行一个周期行任务，该任务在给定的初始延迟后第一次执行，随后在给定的周期内执行;
     * 如果任务的任何执行遇到异常，则禁止后续执行。否则，任务将仅通过执行程序的取消或终止而终止。
     * 如果该任务的任何执行时间超过了它的周期，那么后续执行可能会延迟开始，但不会并发执行。
     */
    private static void m2() {
        System.out.println(getSystemTime() + " 线程" + Thread.currentThread().getName() + " 执行任务");
        scheduledExecutorService.scheduleAtFixedRate(() -> {
            System.out.println(getSystemTime() + " 线程" + Thread.currentThread().getName() + " 执行任务开始");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(getSystemTime() + " 线程" + Thread.currentThread().getName() + " 执行任务结束。。。");
        }, 4, 2, TimeUnit.SECONDS);
    }

    /**
     * 创建并执行一个周期性操作，该操作在给定的初始延迟之后首先启用，然后在一个执行的终止和下一个执行的开始之间使用给定的延迟。
     * 如果任务的任何执行遇到异常，则禁止后续执行。否则，任务将仅通过执行程序的取消或终止而终止。
     * 如果该任务的任何执行时间超过了它的周期，那么后续执行会在前一个任务执行结束后间隔delay后开始，但不会并发执行。
     */
    private static void m3(){
        System.out.println(getSystemTime() + " 线程" + Thread.currentThread().getName() + " 执行任务");
        scheduledExecutorService.scheduleWithFixedDelay(()->{
            System.out.println(getSystemTime() + " 线程" + Thread.currentThread().getName() + " 执行任务开始");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(getSystemTime() + " 线程" + Thread.currentThread().getName() + " 执行任务结束。。。");
        },2,2,TimeUnit.SECONDS);
    }

    public static void main(String[] args) throws InterruptedException {

        m1();
        //m2();
        //m3();



    }

    private static String getSystemTime() {
        return sdf.format(System.currentTimeMillis());
    }
}

方法m1()执行结果如下：
在这里插入图片描述

方法m2()执行结果如下：
在这里插入图片描述

方法m3()执行结果如下：
在这里插入图片描述

5、创建工作窃取的线程池

  创建工作窃取的线程池一共有两个方法，分别如下所示：

public static ExecutorService newWorkStealingPool() {
        return new ForkJoinPool
            (Runtime.getRuntime().availableProcessors(),
             ForkJoinPool.defaultForkJoinWorkerThreadFactory,
             null, true);
    }

public static ExecutorService newWorkStealingPool(int parallelism) {
        return new ForkJoinPool
            (parallelism,
             ForkJoinPool.defaultForkJoinWorkerThreadFactory,
             null, true);
    }

  newWorkStealingPool，这个是 JDK1.8 版本加入的一种线程池，Stealing 翻译为窃取的意思，它对线程池的实现和上面4种都不一样，利用操作系统的 CPU 数目或者指定数目（parallelism）作为线程并发的数量来创建一个工作窃取的线程池，底层使用 ForkJoin 来实现。
  创建一个线程池，该线程池维护足够的线程来支持给定的并行级别，并可以使用多个队列来减少争夺。并行级别对应于可以参与处理任务的最大线程数，线程的实际数量可以动态地增加或减少，工作窃取线程池池不能保证提交任务的顺序执行，抢占式的执行任务。

package com.enjoy.lspj.threadpool;

import java.text.SimpleDateFormat;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 * Executors工厂类
 * <p>
 * 创建工作窃取的线程池:
 * 利用操作系统的CPU数目作为线程并发的数量来创建一个工作窃取的线程池，底层使用 ForkJoin 来实现。
 * <p>
 * 创建一个线程池，该线程池维护足够对的线程来支持给定的并行级别，并可以使用多个队列来减少争夺。
 * 并行性级别对应于可以参与处理任务的最大线程数。
 * 线程的实际数量可以动态地增加或减少。工作窃取线程池池不能保证提交任务的顺序执行。
 * <p>
 * parallelism 表示并发级别，多个线程同时在执行不同的任务。
 * 如果不指定parallelism大小，默认使用Runtime.getRuntime().availableProcessors()获取操作系统的CPU个数作为并发级别。
 */
public class UseExecutorsCreateThreadPool6 {
    final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
    private static ExecutorService executorService = Executors.newWorkStealingPool(4);


    public static void main(String[] args) {

        for (int i = 0; i < 10; i++) {
            int finalI = i;
            executorService.execute(() -> {
                System.out.println(getSystemTime() + " 线程 " + Thread.currentThread().getName() + " 执行任务 " + finalI);
                try {
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }


        while (true) {
        }

    }


    private static String getSystemTime() {
        return sdf.format(System.currentTimeMillis());
    }
}

执行结果如下：
在这里插入图片描述
  通过上面代码示例及其执行结果可知，最明显的用意就是它是一个并行的线程池，参数中传入的是一个线程并发的数量，这里和之前的4种创建线程池的方式有很明显的区别，前面4种线程池都有核心线程数、最大线程数等等，而这就使用了一个并发线程数解决问题。

  如何使用 Executors 工厂创建线程池的5种方法就分析到这里啦，作者能力有限，有分析不到位的地方欢迎各位读者留言讨论，下一篇将详细讲解线程池是如何保证线程池核心线程数不会被销毁及空闲线程数会被销毁的呢？大家拭目以待吧。

备注：博主微信公众号，不定期更新文章，欢迎扫码关注。
在这里插入图片描述

菜鸟技术栈
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JDK8的Executors创建线程池6种方式
hl6164085的博客
12-10 1194
先来看看构造方法创建线程池ThreadPoolExecutor的方式 参数含义： corePoolSize：核心线程数，即使线程处于空闲状态也不被销毁。 maximumPoolSize：线程池允许的最大线程数。 keepAliveTime：当线程数大于核心时，这是多余的空闲线程在终止之前等待新任务的最长时间。 unit：keepAliveTime的时间单位 workQueue：在执行任务之前用于保...
JDK Executors 类中提供了众多工厂方法来创建各种用途的线程池
weixin_44715154的博客
04-25 169
JDK Executors 类中提供了众多工厂方法来创建各种用途的线程池 线程池的构造方法： public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, Block
Executor工厂方法可以创建出哪四种线程池
NewBeeMu的博客
01-16 348
① newCachedThreadPool:创建一个可缓存的线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。 ② newFixedThreadPool:创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。 ③ newScheduledThreadPool:创建一个定长线程池，支持定时及周期性任务执行。 ④ newSingleThreadPool:创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序执行。 ...
Executors四大线程池工厂方法的使用
morris
10-15 1万+
id: 1602583277163 title: 四大线程池的使用 date: 2020-10-13 updated: 2020-10-13 categories: 高并发与多线程 tags: - 高并发与多线程 Executors工厂方法的使用 Executors提供了四个创建线程池的工厂方法，分别是： Executors.newSingleThreadExecutor() Executors.newFixedThreadPool() Executors.newCachedThreadPool() E.
Java-多线程 创建线程池ExecutorService
Adam586007的博客
04-09 800
public class ThreadPool { public static void main(String[] args) { //1.工具类创建线程池 //创建可重用的固定数量线程数的线程池 ExecutorService service = Executors.newFixedThreadPool(10); /* //创建一个线程池，可安排在给定延迟后运行命令或者定期的执行 ExecutorService s.
Java并发编程之基础篇（六）——Executor框架及线程池
IT界的一只菜鸟
06-03 206
这篇主要说一下Executor框架及线程池。 什么是线程池 顾名思义，线程池就是存放线程的池子，池子里面存放的是已经创建好的N个线程；Java里面一般用List或Set等容器类来存储线程，实现线程池功能。 为什么要使用线程池 首先，线程的创建和销毁是很耗费时间和资源的一件事情。 其次，线程不能无限制的创建，每个线程都会占用内存资源，而且如果线程过多，线程之间的调度也是一件很消耗系统性能的事情。 线程池带来的好处 可以做到随用随取，节省因创建线程而花费的时间 通过设置线程池容量，可以保证创建的线程数量在一个合
java并发编程【二】Executor框架与线程池
weixin_44050211的博客
09-03 1318
线程池是池化技术的一种实现，在并发编程中起到了至关重要的的作用
java并发编程_线程池的使用方法(详解)
08-30
java并发编程中，线程池是一种非常重要的概念，它可以帮助我们更好地管理线程，提高程序的性能和可扩展性。下面我们将详细介绍java线程池的使用方法。 一、任务和执行策略之间的隐性耦合 在java中，Executor可以将...
Java并发框架:Executor API详解
08-25
- 避免使用Executors的静态工厂方法直接创建线程池，因为它们默认的配置可能不适应具体应用。 - 适当监控线程池状态，如线程数量、任务队列长度，及时调整配置以保证系统稳定。 通过理解并熟练运用Executor框架，...
Java并发：线程池详解（ThreadPoolExecutor）(1)，2024年最新java实施工程师面试题库及答案
最新发布
2401_84433600的博客
04-20 823
该策略实现了一种调节机制，该策略既不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者（调用线程池执行任务的主线程），从而降低新任务的流程。使用直接移交将更高效，因为任务会直接移交 给执行它的线程，而不是被首先放在队列中, 然后由工作者线程从队列中提取任务. 只有当线程池是无界的或者可以拒绝任务时，SynchronousQueue才有实际价值.如果某个线程的控线时间超过了keepAliveTime，那么将被标记为可回收的，并且当前线程池的当前大小超过了核心线程数时，这个线程将被终止。
线程池 + 工厂模式 + 工厂方法 + 单件模式
12-04
线程池、工厂模式、工厂方法、单件模式、内存池的简单实现，代码量1300 行，有测试样例 ~ 发现有BUG请指正， thx
Java ExecutorService四种线程池使用详解
08-28
Java的`java.util.concurrent`包中提供了`ExecutorService`的实现类，特别是通过`Executors`工厂类可以方便地创建四种类型的线程池，分别是`newCachedThreadPool`、`newFixedThreadPool`、`newScheduledThreadPool` ...
java并发编程：ExecutorService详解
天才小站
09-29 900
接口 java.util.concurrent.ExecutorService 表述了异步执行的机制，并且可以让任务在后台执行。一个 ExecutorService 实例因此特别像一个线程池。事实上，在 java.util.concurrent 包中的 ExecutorService 的实现就是一个线程池的实现。 ExecutorService 样例  这里有一个简单的使用Java 实现的 Exe...
JAVA线程池ExecutorService四种模式的创建、使用及区别
快乐的小码农
07-20 2万+
ExecutorService ExecutorService是Java中对线程池定义的一个接口，它java.util.concurrent包中。Java API对ExecutorService接口的实现有两个（ThreadPoolExecutor和ScheduledThreadPoolExecutor），所以这两个即是Java线程池具体实现类。除此之外，ExecutorService还继...
Java多线程案例之线程池
qq_63218110的博客
01-28 784
本篇介绍Java多线程案例之线程池，主要介绍线程池的概念，线程池的优点，自我实现简单的线程池，怎么确认线程池线程数量，ThreadPoolExecutor(线程池)的工作流程和拒绝策略。
Java:使用Executors创建和管理线程(转载)
a13969726756的专栏
05-22 83
1. 类 Executors 　　此类中提供的一些方法有： 　　1.1 public static ExecutorService newCachedThreadPool() 　　创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。对于执行很多短期异步任务的程序而言，这些线程池通常可提高程序性能。 　　1.2 public static Exec...
java实现线程池(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-08 873
java实现线程池(附完整源码)
Java 线程池的创建——7种方法
xhhhx_的博客
04-23 1万+
线程池的创建分为两大类方法 通过Executors自动创建 通过ThreadPoolExecutor手动创建 Executors创建线程池的方法——6种 newFixedThreadPool：创建一个固定大小的线程池 public class ThreadPool1 { public static void main(String[] args) { //1.创建一个大小为5的线程池 ExecutorService threadPool= Executors.
详解Java 8 中使用Stream将List转为Map
热门推荐
菜鸟技术栈的专栏
06-06 3万+
Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。 下面将详细讲解在Java 8 中如何使用Stream将List转换为Map，使用Collectors.toMap方法进行转换。 背景：User类，类中分别有id，name,age三个属性。List集合,use...
Java网络编程：ServerSocket详解与线程池应用
总结起来，学习Java网络编程模块，要掌握ServerSocket的构造方法，理解端口绑定、连接队列设置以及线程池在服务器程序中的应用。熟练运用这些核心概念和技术，可以编写出健壮且高效的网络服务应用程序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值