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

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 

//使用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;

}

}