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

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：ceponline@yahoo.com.cn 
 *  @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已成为毋庸置疑的核心标准。

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