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	awaitTermination(long timeout, TimeUnit unit) 请求关闭、发生超时或者当前线程中断，无论哪一个首先发生之后，都将导致阻塞，直到所有任务完成执行。
<T> List<Future<T>>	invokeAll(Collection<? extends Callable<T>> tasks) 执行给定的任务，当所有任务完成时，返回保持任务状态和结果的 Future 列表。
<T> List<Future<T>>	invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) 执行给定的任务，当所有任务完成或超时期满时（无论哪个首先发生），返回保持任务状态和结果的 Future 列表。
<T> T	invokeAny(Collection<? extends Callable<T>> tasks) 执行给定的任务，如果某个任务已成功完成（也就是未抛出异常），则返回其结果。
<T> T	invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) 执行给定的任务，如果在给定的超时期满前某个任务已成功完成（也就是未抛出异常），则返回其结果。
boolean	isShutdown() 如果此执行程序已关闭，则返回 true。
boolean	isTerminated() 如果关闭后所有任务都已完成，则返回 true。
void	shutdown() 启动一次顺序关闭，执行以前提交的任务，但不接受新任务。
List<Runnable>	shutdownNow() 试图停止所有正在执行的活动任务，暂停处理正在等待的任务，并返回等待执行的任务列表。
<T> Future<T>	submit(Callable<T> task) 提交一个返回值的任务用于执行，返回一个表示任务的未决结果的 Future。
Future<?>	submit(Runnable task) 提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future。
<T> Future<T>	submit(Runnable task, T result) 提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future。
void	execute(Runnable command) 在未来某个时间执行给定的命令。

自己写的例子：

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