线程池 ExecutorService String readLine()

package com.skex.Thread;


public class TaskException extends Exception {  
    public TaskException(String message) {  
        super(message);  
    }  
}

package com.skex.Thread;

import java.util.Random;
import java.util.concurrent.Callable;

public class TaskWithResult implements Callable<String> {  
    private int id;  

    public TaskWithResult(int id) {  
        this.id = id;  
    }  

    /** 
     * 任务的具体过程，一旦任务传给ExecutorService的submit方法，则该方法自动在一个线程上执行。 
     *  
     * @return 
     * @throws Exception 
     */  
    public String call() throws Exception {  
        System.out.println("call()方法被自动调用,干活！！！             " + Thread.currentThread().getName());  
        //if (new Random().nextBoolean())  
        //    throw new TaskException("Meet error in task." + Thread.currentThread().getName());  
        // 一个模拟耗时的操作  
        for (int i = 999999999; i > 0; i--)  
            ;  
        return "call()方法被自动调用，任务的结果是：" + id + "    " + Thread.currentThread().getName();  
    }  
}

package com.skex.Thread;


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ExecutorServiceTest {  
    
    public static String readLine(){
        InputStreamReader ir = new InputStreamReader(System.in);
        BufferedReader in = new BufferedReader(ir);
        try {
            return in.readLine();            
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }
    
    public static void main(String[] args) {  
        ExecutorService executorService = Executors.newCachedThreadPool();  
        List<Future<String>> resultList = new ArrayList<Future<String>>();  

        // 创建10个任务并执行  
        for (int i = 0; i < 10; i++) {  
            // 使用ExecutorService执行Callable类型的任务，并将结果保存在future变量中  
            Future<String> future = executorService.submit(new TaskWithResult(i));  
            // 将任务执行结果存储到List中  
            resultList.add(future);  
        } 
        System.out.println("executorService.shutdown...");
        executorService.shutdown();  
        System.out.println("executorService.shutdown, press any key to show result......");
        readLine();
        // 遍历任务的结果  
        System.out.println("executorService.shutdown, show result:");
        for (Future<String> fs : resultList) {  
            try {  
                System.out.println(fs.get()); // 打印各个线程（任务）执行的结果  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            } catch (ExecutionException e) {  
                executorService.shutdownNow();  
                e.printStackTrace();  
                return;  
            }  
        }  
    }  
}

call()方法被自动调用,干活！！！             pool-1-thread-2
call()方法被自动调用,干活！！！             pool-1-thread-1
executorService.shutdown...
executorService.shutdown, press any key to show result......
call()方法被自动调用,干活！！！             pool-1-thread-4
call()方法被自动调用,干活！！！             pool-1-thread-8
call()方法被自动调用,干活！！！             pool-1-thread-3
call()方法被自动调用,干活！！！             pool-1-thread-5
call()方法被自动调用,干活！！！             pool-1-thread-6
call()方法被自动调用,干活！！！             pool-1-thread-7
call()方法被自动调用,干活！！！             pool-1-thread-9
call()方法被自动调用,干活！！！             pool-1-thread-10

executorService.shutdown, show result:
call()方法被自动调用，任务的结果是：0    pool-1-thread-1
call()方法被自动调用，任务的结果是：1    pool-1-thread-2
call()方法被自动调用，任务的结果是：2    pool-1-thread-3
call()方法被自动调用，任务的结果是：3    pool-1-thread-4
call()方法被自动调用，任务的结果是：4    pool-1-thread-5
call()方法被自动调用，任务的结果是：5    pool-1-thread-6
call()方法被自动调用，任务的结果是：6    pool-1-thread-7
call()方法被自动调用，任务的结果是：7    pool-1-thread-8
call()方法被自动调用，任务的结果是：8    pool-1-thread-9
call()方法被自动调用，任务的结果是：9    pool-1-thread-10