我们都知道，在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;
/**
* <p>Title: LoonFramework</p>
* <p>Description:利用Future模式进行处理</p>
* <p>Copyright: Copyright (c) 2007</p>
* <p>Company: LoonFramework</p>
* @author chenpeng
* @email：[email]ceponline@yahoo.com.cn[/email]
* @version 0.1
*/
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);
}
}
}
/**
* 实现java.util.concurrent.ThreadFactory接口
* @author chenpeng
*
*/
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<? extends T> getInterface();
/**
* 返回代理的实例
* @return
*/
@SuppressWarnings("unchecked")
public final T getProxyInstance() {
Class<? extends T> 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;
/**
* <p>Title: LoonFramework</p>
* <p>Description:</p>
* <p>Copyright: Copyright (c) 2007</p>
* <p>Company: LoonFramework</p>
* @author chenpeng
* @email：[email]ceponline@yahoo.com.cn[/email]
* @version 0.1
*/
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<? extends DateTest> 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.util.concurrent下主要的接口和类：
Executor：具体Runnable任务的执行者。
ExecutorService:一个线程池管理者，其实现类有多种，比如普通线程池，定时调度线程池ScheduledExecutorService等，我们能把一个
Runnable,Callable提交到池中让其调度。
Future：是与Runnable,Callable进行交互的接口，比如一个线程执行结束后取返回的结果等等，还提供了cancel终止线程。
BlockingQueue：阻塞队列。
下面我写一个简单的事例程序：
FutureProxy .java
package
org.test.concurrent;
/** * <p>Title: LoonFramework</p> * <p>Description:利用Future模式进行处理</p> * <p>Copyright: Copyright (c) 2007</p> * <p>Company: LoonFramework</p> * @author chenpeng * @email：[email]ceponline@yahoo.com.cn[/email] * @version 0.1 */
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); } } } /** * 实现java.util.concurrent.ThreadFactory接口 * @author chenpeng * */ 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<? extends T> getInterface(); /** * 返回代理的实例 * @return */ @SuppressWarnings("unchecked") public final T getProxyInstance() { Class<? extends T> 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;
/** * <p>Title: LoonFramework</p> * <p>Description:</p> * <p>Copyright: Copyright (c) 2007</p> * <p>Company: LoonFramework</p> * @author chenpeng * @email：[email]ceponline@yahoo.com.cn[/email] * @version 0.1 */
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<? extends DateTest> 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已成为毋庸置疑的核心标准。
本文转自 cping 51CTO博客，原文链接:http://blog.51cto.com/cping1982/130173
