Java 线程池的使用实例（包括Runnable和Callable）

为什么80%的码农都做不了架构师？>>>   

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 通过Executor接口的四个工厂方法来实现四种线程池。
 * 每一个线程都是通过调用execute（Runnable command） 方法来执行，该方法接收一个Runnable 实例。
 * @author ZYK
 *
 */
public class CacheThread  {	
	
	public static void main(String args[]){
	
		/*
		 * Executors 提供了一一系列工厂方法来创建线程池，返回的线程池都实现了ExecutorServie接口
		 * 1. Executors.newCachedThreadPool();   //可缓存的线程池
		 * 2. Executors.newScheduledThreadPool(int ); //支持定时和周期性的任务的线程池
		 * 3. Executors.newFixedThreadPool(int nThreads); // 固定数目的线程池
		 * 4. Executors.newSingleThreadExecutor();  //但线程话的线程池
		 */		
		ExecutorService cacheThread =  Executors.newCachedThreadPool();
		//ExecutorService cacheThread =  Executors.newSingleThreadExecutor();
		//ExecutorService cacheThread =  Executors.newScheduledThreadPool(4);
		//ExecutorService cacheThread =  Executors.newFixedThreadPool(4);

		
		
		for(int i=0; i<20; i++){
			final int index = i;
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(i);
			cacheThread.execute(new Runnable() {
				
				@Override
				public void run() {
					System.out.println(Thread.currentThread().getState());
					System.out.println(Thread.currentThread().getName() + "线程被调用了");
					System.out.println(Thread.currentThread().getState());
				}
			});
		}
//		System.out.println(cacheThread.isShutdown());
		//关闭方法，调用后执行之前提交的任务，不再接受新的任务
//		cacheThread.shutdown();
//		System.out.println(cacheThread.isShutdown());
		//是否终止
//		System.out.println(cacheThread.isTerminated());
		//从语义上可以看出是立即停止的意思，将暂停所有等待处理的任务并返回这些任务的列表
//		cacheThread.shutdownNow();
		
	}

}

import java.util.ArrayList;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * 通过线程池来执行任务，和Runnable不同的是，这种方法实现了Callable接口。
 * 可以被ExecutorService执行，但是Runnable任务没有返回值，而Callable任务有返回值
 * @author ZYK *
 */
public class CallableTask {
	
	public static void main(String args[]){
		//这里通过newCacheThread（）方法来实现线程池，当然也可以用其他三种方法
		ExecutorService executorService = Executors.newCachedThreadPool();
		//Future 表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。
		//计算完成后只能使用 get 方法来获取结果，如有必要，计算完成前可以阻塞此方法。
		ArrayList> resultList = new ArrayList>();
		
		//创建10个任务并执行
		for(int i=0; i < 10; i++){
			//使用ExecutorService执行Callalbe类型的任务，并将结果保存在future变量中
			Future future = executorService.submit(new TaskWithResult(i));
			//将任务执行结果存储在List中。
			resultList.add(future);
		}
		for (Future fs : resultList){
			
			try {
				 //一直等待Future的返回结果，直到返回完成，打印输出返回结果。
				while (!fs.isDone());
				System.out.println(fs.get());
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (ExecutionException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}finally{
				//启动一次顺序关闭，执行以前提交的任务，但不接受新任务
				executorService.shutdown();
			}
			}
			
		}
	}


/**
 * @author ZYK
 *实现了Callable 接口，重新定义了call()方法。
 *在此类中，我们可以自定义任务Callable的具体实现和功能，来达到既定的目的。
 *通过调用call（）函数，可以得到要返回的结果
 */
class TaskWithResult implements Callable{
	private int id;
	
	/**
	 * 构造函数
	 * @param id 线程执行时的参数
	 */
	public TaskWithResult(int id){
		this.id = id;
	}
	public String call(){
		System.out.println(Thread.currentThread().getName() + "线程被调用了");
		//返回提示信息，该返回结果将在Future的get方法中得到。
		String res = "call() 方法被调用，任务返回的结果是：" + id + "  " + Thread.currentThread().getName() ;
		return res;
	}
}

转载于:https://my.oschina.net/mzzyk/blog/398730