java.util.concurrent 是在并发编程中很常用的实用工具类。此包包括了几个小的、已标准化的可扩展框架，以及一些提供有用功能的类，没有这些类，这些功能会很难实现或实现起来冗长乏味。下面简要描述主要的组件。另请参阅 locks 和 atomic 包。
目录
执行程序
实现
队列
计时
同步器
并发 Collection
执行程序
接口Executor 是一个简单的标准化接口，用于定义类似于线程的自定义子系统，包括线程池、异步 IO 和轻量级任务框架。根据所使用的具体 Executor 类的不同，可能在新创建的线程中，现有的任务执行线程中，或者调用 execute() 的线程中执行任务，并且可能顺序或并发执行。ExecutorService 提供了多个完整的异步任务执行框架。ExecutorService 管理任务的排队和安排，并允许受控制的关闭。ScheduledExecutorService 子接口添加了对延迟的和定期任务执行的支持。ExecutorService 提供了安排异步执行的方法，可执行由 Callable 表示的任何函数，结果类似于 Runnable。Future 返回函数的结果，允许确定执行是否完成，并提供取消执行的方法。
实现
ThreadPoolExecutor 和 ScheduledThreadPoolExecutor 提供可调的、灵活的线程池。Executors 类提供大多数 Executor 的常见类型和配置的工厂方法，以及使用它们的几种实用工具方法。其他基于 Executor 的实用工具包括具体类 FutureTask，它提供 Future 的常见可扩展实现，以及 ExecutorCompletionService，它有助于协调对异步任务组的处理。
队列
java.util.concurrent ConcurrentLinkedQueue 类提供了高效的、可伸缩的、线程安全的非阻塞 FIFO 队列。java.util.concurrent 中的五个实现都支持扩展的 BlockingQueue 接口，该接口定义了 put 和 take 的阻塞版本：LinkedBlockingQueue、ArrayBlockingQueue、SynchronousQueue、 PriorityBlockingQueue 和 DelayQueue。这些不同的类覆盖了生产者-使用者、消息传递、并行任务执行和相关并发设计的大多数常见使用的上下文。
计时
TimeUnit 类为指定和控制基于超时的操作提供了多重粒度（包括纳秒级）。该包中的大多数类除了包含不确定的等待之外，还包含基于超时的操作。在使用超时的所有情况 中，超时指定了在表明已超时前该方法应该等待的最少时间。在超时发生后，实现会“尽力”检测超时。但是，在检测超时与超时之后再次实际执行线程之间可能要 经过不确定的时间。
同步器
四个类可协助实现常见的专用同步语句。Semaphore 是一个经典的并发工具。CountDownLatch 是一个极其简单但又极其常用的实用工具，用于在保持给定数目的信号、事件或条件前阻塞执行。CyclicBarrier 是一个可重置的多路同步点，在某些并行编程风格中很有用。Exchanger 允许两个线程在集合点交换对象，它在多流水线设计中是有用的。
并发 Collection
除队列外，此包还提供了几个设计用于多线程上下文中的 Collection 实现：ConcurrentHashMap、CopyOnWriteArrayList 和 CopyOnWriteArraySet。
此包中与某些类一起使用的“Concurrent&rdquo前缀;是一种简写，表明 与类似的“同步”类有所不同。例如，java.util.Hashtable 和 Collections.synchronizedMap(new HashMap()) 是同步的，但 ConcurrentHashMap 则是“并发的”。并发集合是线程安全的，但是不受单个排他锁定的管理。在 ConcurrentHashMap 这一特定情况下，它可以安全地允许进行任意数目的并发读取，以及数目可调的并发写入。需要通过单个锁定阻止对集合的所有访问时，“同步”类是很有用的，其 代价是较差的可伸缩性。在期望多个线程访问公共集合的其他情况中，通常“并发”版本要更好一些。当集合是未共享的，或者仅保持其他锁定时集合是可访问的情 况下，非同步集合则要更好一些。
大多数并发 Collection 实现（包括大多数 Queue）与常规的 java.util 约定也不同，因为它们的迭代器提供了弱一致的，而不是快速失败的遍历。弱一致的迭代器是线程安全的，但是在迭代时没有必要冻结集合，所以它不一定反映自迭 代器创建以来的所有更新。
开发实例介绍
我们都知道，在JDK1.5之前，Java中要进行业务并发时，通常需要有程序员独立完成代码实现，而当针对高质量Java多线程并发程序设计时,为防止死蹦等现象的出现，比如使用java之前的wait()、notify()和synchronized等，每每需要考虑性能、死锁、公平性、资源管理以及如何避免线程安全性方面带来的危害等诸多因素，往往会采用一些较为复杂的安全策 略，加重了程序员的开发负担.万幸的是，在JDK1.5出现之后，Sun大神终于为我们这些可怜的小程序员推出了 java.util.concurrent工具包以简化并发完成。开发者们借助于此，将有效的减少竞争条件(race conditions)和死锁线程。concurrent包很好的解决了这些问题，为我们提供了更实用的并发程序模型。
java.util.concurrent下主要的接口和类：
Executor：具体Runnable任务的执行者。
ExecutorService:一个线程池管理者，其实现类有多种，比如普通线程池，定时调度线程池ScheduledExecutorService等，我们能把一个
Runnable,Callable提交到池中让其调度。
Future：是与Runnable,Callable进行交互的接口，比如一个线程执行结束后取返回的结果等等，还提供了cancel终止线程。
BlockingQueue：阻塞队列。
一个简单的事例程序：
FutureProxy .java
package org.test.concurrent;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadFactory;
public abstract class FutureProxy < T > ... {
private final class CallableImpl implements Callable < T > ... {
public T call() throws Exception ... {
return FutureProxy. this .createInstance();
}
}
private static class InvocationHandlerImpl < T > implements InvocationHandler ... {
private Future < T > future;
private volatile T instance;
InvocationHandlerImpl(Future < T > future) ... {
this .future = future;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable ... {
synchronized ( this ) ... {
if ( this .future.isDone()) ... {
this .instance = this .future.get();
} else ... {
while ( ! this .future.isDone()) ... {
try ... {
this .instance = this .future.get();
} catch (InterruptedException e) ... {
Thread.currentThread().interrupt();
}
}
}
return method.invoke( this .instance, args);
}
}
}
private static final class ThreadFactoryImpl implements ThreadFactory ... {
public Thread newThread(Runnable r) ... {
Thread thread = new Thread(r);
thread.setDaemon( true );
return thread;
}
}
private static ExecutorService service = Executors.newCachedThreadPool( new ThreadFactoryImpl());
protected abstract T createInstance();
protected abstract Class getInterface();
@SuppressWarnings( " unchecked " )
public final T getProxyInstance() ... {
Class interfaceClass = this .getInterface();
if (interfaceClass == null || ! interfaceClass.isInterface()) ... {
throw new IllegalStateException();
}
Callable < T > task = new CallableImpl();
Future < T > future = FutureProxy.service.submit(task);
return (T) Proxy.newProxyInstance(interfaceClass.getClassLoader(),
new Class [] ... { interfaceClass } , new InvocationHandlerImpl(future));
}
}
Test.java
package org.test.concurrent;
import java.util.Calendar;
interface DateTest ... {
String getDate();
}
class DateTestImpl implements DateTest ... {
private String _date = null ;
public DateTestImpl() ... {
try ... {
_date += Calendar.getInstance().getTime();
// 设定五秒延迟
Thread.sleep( 5000 );
} catch (InterruptedException e) ... {
}
}
public String getDate() ... {
return " date " + _date;
}
}
class DateTestFactory extends FutureProxy < DateTest > ... {
@Override
protected DateTest createInstance() ... {
return new DateTestImpl();
}
@Override
protected Class getInterface() ... {
return DateTest. class ;
}
}
public class Test ... {
public static void main(String[] args) ... {
DateTestFactory factory = new DateTestFactory();
DateTest[] dts = new DateTest[ 100 ];
for ( int i = 0 ;i < dts.length;i ++ ) ... {
dts[i] = factory.getProxyInstance();
}
// 遍历执行
for (DateTest dt : dts) ... {
System.out.println(dt.getDate());
}
}
}
原来很麻烦的并发处理，现在轻松的得以完成。
我认为，concurrent的优点在于：
功能强大且标准化的类库，实现了很多java thread原生api很费时才能实现的功能。
已经过测试，代码质量有保证，相交自己写代码处理thread，节约了大量的测试时间。
性能上已经过优化，比如以前通过synchronized在并发量大的时候性能会不好，而concurrent大量用到了非阻塞算法，尽量少用锁减少等待时间。
在java并发处理中，concurrent已成为毋庸置疑的核心标准
0 0
