6、java5线程池之固定大小线程池newFixedThreadPool
JDK文档说明：
创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。在任意点，在大多数 nThreads 线程会处于处理任务的活动状态。如果在所有线程处于活动状态时提交附加任务，则在有可用线程之前，附加任务将在队列中等待。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。在某个线程被显式地关闭之前，池中的线程将一直存在。
创建方法：
java.util.concurrent.Executors.newFixedThreadPool(int nThreads) or java.util.concurrent.Executors.newFixedThreadPool(int nThreads, ThreadFactory threadFactory)
调用上面2个方法得到的对象为：ExecutorService
JDK自带的例子：
下面给出了一个网络服务的简单结构，这里线程池中的线程作为传入的请求。它使用了预先配置的 Executors.newFixedThreadPool(int) 工厂方法：
class NetworkService implements Runnable { private final ServerSocket serverSocket; private final ExecutorService pool; public NetworkService(int port, int poolSize) throws IOException { serverSocket = new ServerSocket(port); pool = Executors.newFixedThreadPool(poolSize); } public void run() { // run the service try { for (;;) { pool.execute(new Handler(serverSocket.accept())); } } catch (IOException ex) { pool.shutdown(); } } } class Handler implements Runnable { private final Socket socket; Handler(Socket socket) { this.socket = socket; } public void run() { // read and service request on socket } }
主要的方法：
| boolean | |
|
<T> List<Future<T>> |
invokeAll(Collection<? extends Callable<T>> tasks) 执行给定的任务，当所有任务完成时，返回保持任务状态和结果的 Future 列表。 |
|
|
invokeAll(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
执行给定的任务，当所有任务完成或超时期满时（无论哪个首先发生），返回保持任务状态和结果的 Future 列表。 |
|
|
invokeAny(Collection<? extends Callable<T>> tasks)
执行给定的任务，如果某个任务已成功完成（也就是未抛出异常），则返回其结果。 |
|
|
invokeAny(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
执行给定的任务，如果在给定的超时期满前某个任务已成功完成（也就是未抛出异常），则返回其结果。 |
|
boolean |
isShutdown()
如果此执行程序已关闭，则返回 true。 |
|
boolean |
isTerminated()
如果关闭后所有任务都已完成，则返回 true。 |
|
void |
shutdown()
启动一次顺序关闭，执行以前提交的任务，但不接受新任务。 |
|
List<Runnable> |
shutdownNow()
试图停止所有正在执行的活动任务，暂停处理正在等待的任务，并返回等待执行的任务列表。 |
|
|
submit(Callable<T> task)
提交一个返回值的任务用于执行，返回一个表示任务的未决结果的 Future。 |
|
Future<?> |
submit(Runnable task)
提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future。 |
|
|
|
|
| void |
|
|
自己写的例子：
package com.yzl; import java.util.Random; import java.util.concurrent.Callable; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; public class ThreadPool { public static void main(String[] args) { fixedThreadPool(); } /** * 固定大小的线程池 * * 同时可以处理【参数】个任务，多余的任务会排队，当处理完一个马上就会去接着处理排队中的任务。 * Callable的任务在后面的blog有更详细的文章说明 */ private static void fixedThreadPool(){ ExecutorService es = Executors.newFixedThreadPool(2); //加入5个任务 for(int i=1 ; i<5; i++){ final int task = i; es.execute(new Runnable() { @Override public void run() { for(int j=1; j<=2; j++){ System.out.println("现在运行的是第【 " + task + "】任务"); System.out.println(Thread.currentThread().getName() + "is work , now loop to " + j); if(j==2){ System.out.println("任务 【" + task + "】运行完成"); } try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } } }); } System.out.println("5个Runnable任务submit完成!!"); //加入5个Callable任务，该任务执行完后是有返回值的则会发生堵塞，也就是取到5个任务的结果后才会继续往下走 for(int i=1 ; i<=5; i++){ final int task = i; Future<Integer> future = es.submit(new Callable<Integer>() { @Override public Integer call() throws Exception { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Callable 任务【" + task + "】运行"); return new Random().nextInt(100); } }); //如果注释取结果的代码，则不会堵塞 /*try { System.out.println("任务【" + i + "】返回的结果：" + future.get()); } catch (Exception e) { e.printStackTrace(); }*/ } System.out.println("5个Callable任务submit完成!!" + System.currentTimeMillis() ); //虽然shutdown方法是等所有任务跑完后才真正停掉线程池，但该方法不会造成堵塞，也就是这代码运行后，下一行代码会立刻运行 es.shutdown(); System.out.println("主程序shutdown后退出!!" + System.currentTimeMillis()); //暴力的直接终止线程池 //es.shutdownNow(); //awaitTermination方法是堵塞式的，只有等真的把线程池停掉才会让程序继续往下执行 try { es.awaitTermination(2, TimeUnit.SECONDS); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("主程序后awaitTermination退出!!" + System.currentTimeMillis()); } }
