简单的创建多线程方式，创建一个线程（和后续的销毁）开销是非常昂贵的，因为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://blog.csdn.net/coding_or_coded/article/details/6856014
http://blog.csdn.net/linghu_java/article/details/17123057
http://developer.51cto.com/art/201203/321042.htm
