浅谈java.util.concurrent包的并发处理

我们都知道，在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 protected] 
 *  @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 protected] 
 *  @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已成为毋庸置疑的核心标准。

转载：http://blog.csdn.net/cping1982/archive/2007/12/12/1931539.aspx