Java线程池Executors的使用

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

• 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();
    }
}

运行结果：

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

使用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();
    }
}

运行结果：

从以上结果可以看出，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();
    }
}

运行结果：

结果依次输出，相当于顺序执行各个任务。
使用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();
    }
}

运行结果：

我们可以使用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://zhangjunhd.blog.51cto.com/113473/70068/

http://developer.51cto.com/art/201203/321042.htm