标签：
Java并发编程中使用Executors类创建和管理线程的用法
1.类 Executors
Executors类可以看做一个“工具类”。援引JDK1.6 API中的介绍：
此包中所定义的 Executor、ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable 类的工厂和实用方法。此类支持以下各种方法：
通过这个类能够获得多种线程池的实例，例如可以调用newSingleThreadExecutor()获得单线程的ExecutorService，调 用newFixedThreadPool()获得固定大小线程池的ExecutorService，等等。拿到ExecutorService可以做的事情就比 较多了，最简单的是用它来执行Runnable对象，也可以执行一些实现了Callable<T>的对象。用Thread的start()方 法没有返回值，如果该线程执行的方法有返回值那用ExecutorService就再好不过了，可以选择submit()、invokeAll()或者 invokeAny()，根据具体情况选择合适的方法即可。此类中提供的一些方法有：
1.1 public static ExecutorService newCachedThreadPool()
创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。对于执行很多短期异步任务的程序而言，这些线程池通常可提高程序性能。
1.2 public static ExecutorService newFixedThreadPool(int nThreads)
创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。
1.3 public static ExecutorService newSingleThreadExecutor()
创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。
2. 接口 ThreadFactory
根据需要创建新线程的对象。使用线程工厂就无需再手工编写对 new Thread 的调用了，从而允许应用程序使用特殊的线程子类、属性等等。此接口最简单的实现就是：
class SimpleThreadFactory implements ThreadFactory {
public Thread newThread(Runnable r) {
return new Thread(r);
}
}
3. 接口ExecutorService
该接口提供了管理终止的方法。
4.创建标准线程池启动线程
4.1 提供一个简单的实现Runnable接口的线程
public class MyThread implements Runnable {
private int count = 1, number;
public MyThread(int num) {
number = num;
System.out.println("Create Thread-" + number);
}
public void run() {
while (true) {
System.out.println("Thread-" + number + " run " + count+" time(s)");
if (++count == 3)
return;
}
}
}
4.2使用CachedThreadPool启动线程
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CachedThreadPool {
public static void main(String[] args) {
ExecutorService exec = Executors.newCachedThreadPool();
for (int i = 0; i < 5; i++)
exec.execute(new MyThread(i));
exec.shutdown();
}
}
4.3 使用FixedThreadPool启动线程
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
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(i));
exec.shutdown();
}
}
4.4 使用SingleThreadExecutor启动线程
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class SingleThreadExecutor {
public static void main(String[] args) {
ExecutorService exec = Executors.newSingleThreadExecutor();
for (int i = 0; i < 5; i++)
exec.execute(new MyThread(i));
exec.shutdown();
}
}
5.配合ThreadFactory接口的使用
给线程加入daemon和priority的属性设置 设置后台线程属性，设置优先级属性
import java.util.concurrent.ThreadFactory;
public class MaxPriorityThreadFactory implements ThreadFactory {
public Thread newThread(Runnable r) {
Thread t = new Thread(r);
t.setPriority(Thread.MAX_PRIORITY);
return t;
}
}
import java.util.concurrent.ThreadFactory;
public class DaemonThreadFactory implements ThreadFactory {
public Thread newThread(Runnable r) {
Thread t = new Thread(r);
t.setDaemon(true);
return t;
}
}
//最低优先级
import java.util.concurrent.ThreadFactory;
public class MinPriorityThreadFactory implements ThreadFactory {
public Thread newThread(Runnable r) {
Thread t = new Thread(r);
t.setPriority(Thread.MIN_PRIORITY);
return t;
}
}
5.3启动带有属性设置的线程
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ExecFromFactory {
public static void main(String[] args) throws Exception {
ExecutorService defaultExec = Executors.newCachedThreadPool();
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++)
daemonExec.execute(new MyThread(i));
for (int i = 10; i < 20; i++)
if (i == 10)
maxPriorityExec.execute(new MyThread(i));
else if (i == 11)
minPriorityExec.execute(new MyThread(i));
else
defaultExec.execute(new MyThread(i));
}
}
参考文章：
1. Java多线程与并发
2. Java 线程池的使用
标签：
原文地址：http://www.cnblogs.com/wisdo/p/5793307.html
