七．Callable和Future接口
C#可以把任意方法包装成线程执行体，包括那些有返回值的方法。Java也从jdk1.5开始，加入了Callable接口用来扩展Runnable接口的功能，Callable接口提供一个call（）来增强Runnable的run()。因为call（）可以有返回值，可以声明抛出异常。
但是Callable是新增的接口 并没有继承Runnable接口，那么肯定不能作为Runnable target来直接作为Thread构造方法的参数。必须由一个中间的类来包装Callable对象。这个类就是实现了Future接口（继承至Runnable接口）的FutureTask类。
CODE：
1import java.util.concurrent.Callable; 2 3public class CallableThread implements Callable<Integer> { 4@Override 5public Integer call() throws Exception { 6int i=0; 7for(;i<6;i++){ 8System.out.println(Thread.currentThread().getName()+"循环："+i); 9} 10return i; 11} 12} 13---------------------------------------------------------------------------- 14public class TestCallable { 15public static void main(String []args){ 16try { 17CallableThread ct=new CallableThread(); 18FutureTask<Integer> target=new FutureTask<Integer>(ct); 19for(int i=0;i<5;i++){ 20System.out.println(Thread.currentThread().getName()+"循环变量："+i); 21if(i==2){ 22new Thread(target,"子线程").start(); 23//boolean isDone（）：如果Callable任务已完成，则返回true，否则返回false 24System.out.println(target.isDone()); 25Thread.sleep(1); 26} 27} 28//V get():返回Callable任务里call（）的返回值，调用该方法会导致阻塞,必须等到子线程结束时才会得到返回值 29System.out.println("子返回值是："+target.get()); 30System.out.println(target.isDone()); 31} catch (InterruptedException e) { 32e.printStackTrace(); 33} catch (ExecutionException e) { 34e.printStackTrace(); 35} 36} 37} 38----------- 39结果： 40main循环变量：0 41main循环变量：1 42main循环变量：2 43false 44子线程循环：0 45子线程循环：1 46子线程循环：2 47子线程循环：3 48子线程循环：4 49main循环变量：3 50子线程循环：5 51main循环变量：4 52子返回值是：6 53true
八．线程池
Jdk1.5后java也内置支持线程池，为了提高性能。（当程序中需要创建大量生存期很短暂的线程时，更应该考虑使用线程池）
Jdk1.5提供一个Executors工厂类来产生线程池。工厂类中包含5个静态工厂方法来创建线程池：
一.返回类型是ExecutorService 的共3个：
1. newFixedThreadPool(int nThreads)
创建一个可重用的，具有固定线程数的线程池
CODE：
1public static ExecutorService newFixedThreadPool(int nThreads) { 2 return new ThreadPoolExecutor(nThreads, nThreads, 3 0L, TimeUnit.MILLISECONDS, 4 new LinkedBlockingQueue<Runnable>()); 5}
2. ExecutorService newCachedThreadPool()
创建一个具有缓存功能的线程池，系统根据需要创建线程，这些线程将会被缓存在线程池中。
CODE：
1public static ExecutorService newCachedThreadPool() { 2 return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 3 60L, TimeUnit.SECONDS, 4 new SynchronousQueue<Runnable>()); 5}
3.newSingleThreadExecutor()
创建一个只有单线程的线程池，等于newFixedThreadPool（1）。
CODE：
1public static ExecutorService newSingleThreadExecutor() { 2 return new FinalizableDelegatedExecutorService 3 (new ThreadPoolExecutor(1, 1, 4 0L, TimeUnit.MILLISECONDS, 5 new LinkedBlockingQueue<Runnable>())); 6 }
二.返回类型是ScheduledExecutorService（是ExecutorService的子类） 的共2个：
1.newSingleThreadScheduledExecutor()
创建只有一条线程的线程池，它可以在指定延迟后执行线程任务
CODE：
1public static ScheduledExecutorService newSingleThreadScheduledExecutor() { 2 return new DelegatedScheduledExecutorService 3 (new ScheduledThreadPoolExecutor(1)); 4 }
2.newScheduledThreadPool(int corePoolSize)
创建具有指定线程数的线程池，它可以在指定延迟后执行线程任务。其中参数指池中所保存的线程数，即使线程时空闲的也被保存在线程池内。
CODE：
1public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) { 2 return new ScheduledThreadPoolExecutor(corePoolSize); 3 }
ExecutorService代表尽快执行线程的线程池（只要线程池中有空闲线程立即执行线程任务），程序只需要传入Runnable或Callable对象即可。
ExecutorService提供三个方法来执行线程：
1.Future<?>submit（Runnable target）：Runnable中run是没有返回值的所以执行完成后返回null，可以调用Future的isDone（），isCanclled（）来判断当前target的执行状态。
2.<T>Future<T>submit(Runnable target,T result):因为Runnable中run是没有返回值，这里显示指定该Runnable对象线程执行完成返回一个值，这个值就是result。
3.<T>Future<T>submit(Callable<T> target):Callable中的call是有返回值的
ScheduledExecutorService提供以下四个方法：
1.ScheduledFuture<V> schedule(Callable(V) c,long delay,TimeUnit unit):指定c任务将在delay延迟后执行。
2.ScheduledFuture<?> shedule（Runnable r,long delay,TimeUnit unit）:指定r任务将在delay延迟后执行。
3.ScheduledFuture<?> scheduleAtFixedRate(Runnable r,long initialDelay,long period,TimeUnit unit):指定r任务将在delay延迟后执行，而且以设定的频率重复执行（在initialDelay后开始执行，然后开始依次在initialDelay+period,initialDelay+period*2...处重复执行）。
4.ScheduledFuture<?>scheduledWithFixedDelay(Runnable r,long nitialDelay,long delay,TimeUnit unit）：创建并执行一个在给定初始延迟后首次启用的定期操作，随后，在每一次执行中止和下一次执行开始之间都存在给定的延迟。如果任务的任意依次执行时异常，就会取消后序执行。否则，只能通过程序来显示取消或中止该任务。
当用完一个线程池后，应该调用该线程池的shutdown（）方法，启用了shutdown()方法后线程池不再接受新任务，但会将以前所有已提交的任务执行完成,然后启动线程池的关闭序列。
当线程池所有任务都执行完成后，池中所有线程都会死亡，另外也可以调用线程池的shutdownNow（）方法来关闭线程池，该方法试图停止所有正在执行的活动任务，暂停处理正在等待的任务，并返回等待执行的任务列表。
例子：
1class TestThread implements Runnable{ 2public void run() { 3 for(int i=0;i<10;i++){ 4 System.out.println(Thread.currentThread().getName()+":"+i); 5 } 6} 7} 8public class ThreadPoolTest { 9public static void main(String []args){ 10//创建一个固定线程数为3的线程池 11ExecutorService pool=Executors.newFixedThreadPool(3); 12//像线程池提交10个线程 13for(int i=0;i<10;i++){ 14 pool.submit(new TestThread()); 15 if(i==4){ 16 17 18 } 19} 20//执行完成后关闭线程 21pool.shutdown(); 22} 23} 24结果： 25pool-1-thread-2:1 26pool-1-thread-2:2 27pool-1-thread-2:3 28pool-1-thread-1:9 29pool-1-thread-3:8 30pool-1-thread-3:9 31pool-1-thread-2:4 32......
九．附录：线程相关的类
1.ThreadLocal(线程局部变量)
为了避免并发线程的安全问题，可以添加支持泛型的ThreadLocal类（ThreadLocal<T>）。通过使用ThreadLocal可以简化多线程编程时的并发访问，使用这个工具类可以很简洁的写出有没的多线程程序（例如Hibernate的官方提供HibernateUtil类里设置当前线程的局部变量是当前线程副本中session的值）：
Hibernate代码：
1public class HibernateUtil { 2/** 日志 */ 3private static final Log LOG=LogFactory.getLog(HibernateUtil.class); 4/** 线程本地变量*/ 5private static final ThreadLocal MAP = new ThreadLocal(); 6/** 会话工厂 */ 7private static final SessionFactory SESSION_FACTORY; 8private HibernateUtil() { 9} 10static { 11try { 12LOG.debug("HibernateUtil.static - loading config"); 13SESSION_FACTORY = new Configuration().configure() 14.buildSessionFactory(); 15LOG.debug("HibernateUtil.static - end"); 16} catch (HibernateException e) { 17throw new RuntimeException("建立会话工厂错误" + e.getMessage(), e); 18} 19} 20/** 21 * 获得一个会话从当前的线程变量，当这个任务完成后，用户必须返回会话关闭方法 22 */ 23public static Session currentSession()throws HibernateException{ 24Session session=(Session)MAP.get(); 25//如果会话还没有，就打开会话 26if(session==null){ 27session=SESSION_FACTORY.openSession(); 28//设置此线程局部变量的值是当前线程副本中session的值 29MAP.set(session); 30} 31return session; 32} 33/** 34 * 关闭会话 35 */ 36public static void closeSession(){ 37Session session=(Session)MAP.get(); 38MAP.set(null); 39if(session!=null){ 40session.close(); 41} 42} 43}
根据上面代码来看：
线程局部变量功能很简单，就是为每一个使用该变量的线程都提供一个变量值的副本，使每一个线程都可以独立地改变自己的副本，而不会和其他线程的副本冲突。仿佛就好像每一个线程都可以完全拥有该变量
ThreadLocal类提供的常用方法：
1.T get()：返回此线程局部变量中当前线程副本中的值。
2.void remove()：删除此线程局部变量中当前线程的值。
3.void set（T value）：设置此线程局部变量中当前线程副本中的值。
CODE：
1/** 2 * 线程局部变量测试 3 * @author Cloudy 4 * 5 */ 6class Accout{ 7//定义一个ThreadLocal变量，只要调用该类的线程都会保留该变量的一个副本 8private ThreadLocal<String> threadLocal=new ThreadLocal<String>(); 9//初始化threadLocal 10public Accout(String str) { 11this.threadLocal.set(str); 12System.out.println("-------初始化（为ThreadLocal在main中副本）值是："+this.threadLocal.get()); 13} 14public String getThreadLocal() { 15return threadLocal.get(); 16} 17public void setThreadLocal(String threadLocal) { 18this.threadLocal.set(threadLocal); 19} 20} 21/**定义一个线程*/ 22class MyThread implements Runnable{ 23//模拟一个Accout 24private Accout accout; 25public MyThread(Accout accout) { 26super(); 27this.accout = accout; 28} 29//线程执行体 30public void run() { 31for(int i=0;i<3;i++){ 32if(i==2){ 33//设置此线程局部变量的值为当前线程名字 34accout.setThreadLocal(Thread.currentThread().getName()); 35} 36System.out.println(i+"------"+Thread.currentThread().getName()+"线程局部变量副本值："+accout.getThreadLocal()); 37} 38} 39} 40public class ThreadLocalVarTest { 41public static void main(String []args){ 42ExecutorService pool=Executors.newFixedThreadPool(3); 43//启动三条线程，公用同一个Accout 44Accout ac=new Accout("ThreadLocal本尊"); 45/* 46 * 虽然Accout类的只有一个变量所以ThreadLocal类型的变量就导致了同一个Accout对象， 47 * 当i=2后，将会看到3条线程访问同一个ac 而看到不同的ThreadLocal值。 48 */ 49pool.submit(new MyThread(ac)); 50pool.submit(new MyThread(ac)); 51pool.submit(new MyThread(ac)); 52pool.shutdown(); 53} 54}
结果：
-------初始化（为ThreadLocal在main中副本）值是：ThreadLocal本尊
0------pool-1-thread-1线程局部变量副本值：null
1------pool-1-thread-1线程局部变量副本值：null
2------pool-1-thread-1线程局部变量副本值：pool-1-thread-1
0------pool-1-thread-2线程局部变量副本值：null
1------pool-1-thread-2线程局部变量副本值：null
2------pool-1-thread-2线程局部变量副本值：pool-1-thread-2
0------pool-1-thread-3线程局部变量副本值：null
1------pool-1-thread-3线程局部变量副本值：null
2------pool-1-thread-3线程局部变量副本值：pool-1-thread-3
总结：
ThreadLocal并不能代替同步机制，两者面向的问题领域不同，同步机制是为了多个线程同步对相同资源的并发访问，是多个线程之间进行通信的有效方式。而ThreadLocal是隔离多个线程的数据共享，根本就没有在多个线程之间共享资源，也就更不用对多个线程同步了。
所以：如果进行多个线程之间共享资源，达到线程之间通信功能，就同步。
如果仅仅需要隔离多个线程之间的共享冲突，就是用ThreadLocal。
1.包装线程不安全的集合成为线程安全集合
Java集合中的ArrayList，LinkedList，HashSet，TreeSet，HashMap都是线程不安全的（线程不安全就是当多个线程想这些集合中放入一个元素时，可能会破坏这些集合数据的完整性）
如何将上面的集合类包装成线程安全的呢？
例子：使用Collections的synchronizedMap方法将一个普通HashMap包装成线程安全的类
HashMap hm=Collections.synchronizedMap(new Map());
如果需要包装某个集合成线程安全集合，则应该在创建之后立即包装如上。
3.线程安全的集合类
位于java.util.concurrent包下的ConcurrentHashMap集合和ConcurrentLinkedQueue集合都支持并发访问，分别对应支持并发访问的HashMap和Queue，它们都可以支持多线程并发写访，这些写入线程的所有操作都是线程安全的，但读取的操作不必锁定。（为什么？因为算法 我也看不懂）
当多个线程共享访问一个公共集合时，使用ConcurrentLinkedQueue是一个恰当的选择，因为ConcurrentLinkedQueue不允许使用null元素。ConcurrentLinkedQueue实现了多线程的高效访问，多线程访问ConcurrentLinkedQueue集合时不需要等待。
ConcurrentHashMap支持16条多线程并发写入。
用迭代器访问这两种可支持多线程的集合而言，该迭代器可能不反应出创建迭代器之后所做的修改，但不会抛出异常，而如果Collection作为对象，迭代器创建之后修改，则会抛出ConcurrentModificationException。