多线程框架executor

/**
 * newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程
 * @author Administrator
 *
 */
public class NewCachedThreadPoolDemo{   
    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);   
        }   

        //遍历任务的结果   
        for (Future<String> fs : resultList){   
                try{   
                    while(!fs.isDone());//Future返回如果没有完成，则一直循环等待，直到Future返回完成  
                    System.out.println(fs.get());     //打印各个线程（任务）执行的结果   
                }catch(InterruptedException e){   
                    e.printStackTrace();   
                }catch(ExecutionException e){   
                    e.printStackTrace();   
                }finally{   
                    //启动一次顺序关闭，执行以前提交的任务，但不接受新任务  
                    executorService.shutdown();   
                }   
        }   
    }   
}   


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

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

    /**  
     * 任务的具体过程，一旦任务传给ExecutorService的submit方法， 
     * 则该方法自动在一个线程上执行 
     */   
    public String call() throws Exception {  
        System.out.println("call()方法被自动调用！！！    " + Thread.currentThread().getName());   
        //该返回结果将被Future的get方法得到  
        return "call()方法被自动调用，任务返回的结果是：" + id + "    " + Thread.currentThread().getName();   
    }   
}  

/**
 * newFixedThreadPool创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。
 * @author Administrator
 *
 */
public class NewFixedThreadPoolDemo {

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		ExecutorService executorService = Executors.newFixedThreadPool(5);
		
		for (int i = 0; i < 20; i++) {
			Future<String> future = executorService.submit(new TestThread(i));
			System.out.println(future.get());
		}

	}

}

class TestThread implements Callable<String>{
	private int id;

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

	@Override
	public String call() throws Exception {
//        System.out.println("call()方法被自动调用！！！    " + Thread.currentThread().getName());   
        //该返回结果将被Future的get方法得到  
        return "call()方法被自动调用，任务返回的结果是：" + id + "    " + Thread.currentThread().getName();  
	}

}

/**
 * newScheduledThreadPool创建一个定长线程池，支持定时及周期性任务执行
 * @author Administrator
 *
 */
public class NewScheduledThreadPoolDemo {

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		ExecutorService executorService = Executors.newScheduledThreadPool(5);
		for (int i = 0; i < 20; i++) {
			Future<String> future = executorService.submit(new TestThread2(i));
			System.out.println(future.get());
		}

	}

}

class TestThread2 implements Callable<String>{
	private int id;

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

	@Override
	public String call() throws Exception {
//        System.out.println("call()方法被自动调用！！！    " + Thread.currentThread().getName());   
        //该返回结果将被Future的get方法得到  
        return "call()方法被自动调用，任务返回的结果是：" + id + "    " + Thread.currentThread().getName();  
	}

}

/**
 * newSingleThreadExecutor创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行
 * @author Administrator
 *
 */
public class NewSingleThreadExecutorDemo {
	public static void main(String... args) throws InterruptedException,
			ExecutionException {
		ExecutorService executorService = Executors.newSingleThreadExecutor();
		
		for (int i = 0; i < 20; i++) {
			Future<String> future = executorService.submit(new TestThread3(i));
			System.out.println(future.get());
		}
	}
}

class TestThread3 implements Callable<String>{
	private int id;

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

	@Override
	public String call() throws Exception {
//        System.out.println("call()方法被自动调用！！！    " + Thread.currentThread().getName());   
        //该返回结果将被Future的get方法得到  
        return "call()方法被自动调用，任务返回的结果是：" + id + "    " + Thread.currentThread().getName();  
	}

}