Java线程池Executors的使用

- 日理万妓 2021-09-22 09:42 359阅读 0赞

简单的创建多线程方式，创建一个线程（和后续的销毁）开销是非常昂贵的，因为JVM和操作系统都需要分配资源。而且创建的线程数也是不可控的，这将可能导致系统资源被迅速耗尽。为了能更好的控制多线程，JDK提供了一套Executor框架，其本质就是一个线程池，它的核心成员如下：

![70][]

*  Executor：一个接口，其定义了一个接收Runnable对象的方法executor，其方法签名为executor(Runnable command)
 *  ExecutorService：是一个比Executor使用更广泛的子类接口，其提供了生命周期管理的方法，以及可跟踪一个或多个异步任务执行状况返回Future的方法
 *  AbstractExecutorService：ExecutorService执行方法的默认实现
 *  ScheduledExecutorService：一个可定时调度任务的接口
 *  ScheduledThreadPoolExecutor：ScheduledExecutorService的实现，一个可定时调度任务的线程池
 *  ThreadPoolExecutor：表示一个线程池，可以通过调用Executors的静态工厂方法来创建一个拥有特定功能的线程池并返回一个ExecutorService对象

以上成员均在 java.util.concurrent包中, 是 JDK并发包的核心类。其中ThreadpoolExecutor表示一个线程池。 Executors类则扮演着线程池工厂的角色,通过 Executors可以取得一个拥特定功能的线程池。从 UML图中亦可知, ThreadPoolExecutor类实现了 Executor接口, 因此通过这个接口, 任何 Runnable的对象都可以被 ThreadPoolExecutor线程池调度。

### Executor框架提供了各种类型的线程池, 主要有以下工厂方法: ###

● public static ExecutorService newCachedThreadPool()  
创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程，但是在以前构造的线程可用时将重用它们。对于执行很多短期异步任务的程序而言，这些线程池通常可提高程序性能。  
● public static ExecutorService newFixedThreadPool(int nThreads)  
创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程，超出的线程会在队列中等待。  
● public static ExecutorService newSingleThreadExecutor()  
创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。  
● public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)  
创建一个定长线程池，支持定时及周期性任务执行。

前三个方法都可以配合接口ThreadFactory的实例一起使用。并且返回一个ExecutorService接口的实例

### 计划任务 ###

ScheduledExecutorService 可以根据时间需要对线程进行调度,ScheduledExecutorService并不一定会立即安排执行任务。它其实是起到了计划任务的作用，它会在指定的时间对任务进行调度。主要方法如下:

*  public ScheduledFuture<?> schedule(Runnable command,long delay, TimeUnit unit);
 *  public ScheduledFuture<?> scheduleAtFixedRate(Runnable comnand,long initialDelay,long period,TimeUnit unit);
 *  public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,long initialDelay,long delay,TimeUnit unit)

方法schedule( )会在给定时间,对任务进行一次调度。方法 scheduleAtFixedRate( )和 scheduleWithFixedDelay( )会对任务进行周期性的调度。

### 创建标准线程池启动线程 ###

下面我们通过一些简单的例子来说明如何使用线程池，首先创建一个简单的实现Runnable接口的线程

public class MyThread implements Runnable {
        public MyThread() {
        }
        public void run() {
            System.out.println(Thread.currentThread().getName() + "正在执行。。。");
        }
    }

使用CachedThreadPool启动线程

public class CachedThreadPool {
        public static void main(String[] args) {
            ExecutorService exec = Executors.newCachedThreadPool();
            for (int i = 0; i < 5; i++)
                exec.execute(new MyThread());
            exec.shutdown();
        }
    }

运行结果：

![70 1][]

这种方式的特点是：可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们

使用FixedThreadPool启动线程

public class FixedThreadPool {
        public static void main(String[] args) {
            ExecutorService exec = Executors.newFixedThreadPool(2);
            for (int i = 0; i < 5; i++)
                exec.execute(new MyThread());
            exec.shutdown();
        }
    }

运行结果：

![Center][]

从以上结果可以看出，newFixedThreadPool的参数指定了可以运行的线程的最大数目，超过这个数目的线程加进去以后，不会运行。其次，加入线程池的线程属于托管状态，线程的运行不受加入顺序的影响。

定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()  
  
使用SingleThreadExecutor启动线程

public class SingleThreadExecutor {
        public static void main(String[] args) {
            ExecutorService exec = Executors.newSingleThreadExecutor();
            for (int i = 0; i < 5; i++)
                exec.execute(new MyThread());
            exec.shutdown();
        }
    }

运行结果：

![Center 1][]

结果依次输出，相当于顺序执行各个任务。  
使用ScheduledThreadPool启动线程

public class ScheduledThreadPool {
        public static void main(String[] args) {
            // 创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
            ScheduledExecutorService exec = Executors.newScheduledThreadPool(2);
                MyThread t1 = new MyThread();
                exec.execute(t1);// 将线程放入池中进行执行
                MyThread t2 = new MyThread();
                exec.schedule(t2, 1000, TimeUnit.MILLISECONDS);// 使用延迟执行风格的方法
                exec.shutdown();
        }
    }

运行结果：

![Center 2][]

我们可以使用JDK自带的监控工具来监控我们创建的线程数量，运行一个不终止的线程，创建指定量的线程来观察：

我的工具目录：D:\\jdk1.8.0\_92\\bin\\jconsole.exe

### **接口 ThreadFactory** ###

根据需要创建新线程的对象，使用线程工厂就无需再手工编写对 new Thread 的调用了，从而允许应用程序使用特殊的线程子类、属性等等。

此接口最简单的实现就是：

public class SimpleThreadFactory implements ThreadFactory {
        public Thread newThread(Runnable r) {
            return new Thread(r);
        }
    }

### 配合ThreadFactory接口的使用 ###

前三个方法都可以配合接口ThreadFactory的实例一起使用,并且返回一个ExecutorService接口的实例,我们试图给线程加入daemon和priority的属性设置。

/** 设置后台线程属性
     * Created by xmr on 2017/6/6.
     */
    public class DaemonThreadFactory implements ThreadFactory {
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r);
            t.setDaemon(true);
            return t;
        }
    }
     /** 设置优先级属性
    *最高优先级
     */
    public class MaxPriorityThreadFactory implements ThreadFactory {
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r);
            t.setPriority(Thread.MAX_PRIORITY);
            return t;
        }
    }
    /**
     * 启动带有属性设置的线程
     * Created by xmr on 2017/6/6.
     */
    public class ExecFromFactory {
        public static void main(String[] args) throws Exception {
            ExecutorService executorService = Executors.newCachedThreadPool();
    
            ExecutorService defaultExec = Executors
                    .newCachedThreadPool(Executors.defaultThreadFactory());
            ExecutorService daemonExec = Executors
                    .newCachedThreadPool(new DaemonThreadFactory());
            ExecutorService maxPriorityExec = Executors
                    .newCachedThreadPool(new MaxPriorityThreadFactory());
            ExecutorService minPriorityExec = Executors
                    .newCachedThreadPool(new MinPriorityThreadFactory());
            for (int i = 0; i < 10; i++) {
                if (i == 1)
                    defaultExec.execute(new MyThread());
                else if (i == 3)
                    daemonExec.execute(new MyThread());
                else if (i == 5)
                    maxPriorityExec.execute(new MyThread());
                else if (i == 7)
                    minPriorityExec.execute(new MyThread());
                else
                    executorService.execute(new MyThread());
            }
        }
    }

就这么多了，小弟才疏学浅，如有不当之处，还请多多请教，大家共同学习，谢谢了

参考：

[http://cuisuqiang.iteye.com/blog/2019372][http_cuisuqiang.iteye.com_blog_2019372]

[http://zhangjunhd.blog.51cto.com/113473/70068/][http_zhangjunhd.blog.51cto.com_113473_70068]

[http://blog.csdn.net/coding\_or\_coded/article/details/6856014][http_blog.csdn.net_coding_or_coded_article_details_6856014]

[http://blog.csdn.net/linghu\_java/article/details/17123057][http_blog.csdn.net_linghu_java_article_details_17123057]

[http://developer.51cto.com/art/201203/321042.htm][http_developer.51cto.com_art_201203_321042.htm]

[70]: /images/20210920/33e46be84f6d43b58a6e7133a3833a47.png
[70 1]: /images/20210920/62172e59ebc84441a6d072333cadbcaa.png
[Center]: /images/20210920/1ea87b6c62f34b5090ba9b2ec0d2ca62.png
[Center 1]: /images/20210920/7fee8904b1ea4ac88d843895b307ff99.png
[Center 2]: /images/20210920/bbe19480835b420a90069362f2d3a450.png
[http_cuisuqiang.iteye.com_blog_2019372]: http://cuisuqiang.iteye.com/blog/2019372
[http_zhangjunhd.blog.51cto.com_113473_70068]: http://zhangjunhd.blog.51cto.com/113473/70068/
[http_blog.csdn.net_coding_or_coded_article_details_6856014]: http://blog.csdn.net/coding_or_coded/article/details/6856014
[http_blog.csdn.net_linghu_java_article_details_17123057]: http://blog.csdn.net/linghu_java/article/details/17123057
[http_developer.51cto.com_art_201203_321042.htm]: http://developer.51cto.com/art/201203/321042.htm