浅谈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：阻塞队列。

SynchronousQueue ：也是一种阻塞队列

 

Semaphore：一个计数信号量（类似于一把锁的钥匙，谁得到这个把锁的钥匙，谁就可以打开们，如果一个人不交出钥匙，后面的人都不可以打开门）

下面写一个简单的示例程序：

 

FutureProxy.java

 

packageorg.test.concurrent;
/**
 * <p>Title: LoonFramework</p>
 * <p>Description:利用Future模式进行处理</p>
 * <p>Copyright: Copyright (c) 2007</p>
 * <p>Company: LoonFramework</p>
 * @author chenpeng
 * @email：[e-mail]
 * @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 abstractclass FutureProxy<T>{
    private finalclass CallableImplimplementsCallable<T>{
        public T call()throwsException{
            return FutureProxy.this.createInstance();
        }
    }
    private staticclass InvocationHandlerImpl<T>implementsInvocationHandler{
        private Future<T>future;
        
        private volatile T instance;
        
        InvocationHandlerImpl(Future<T>future){
            this.future=future;
        }
        
        public Objectinvoke(Objectproxy,Methodmethod,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 staticfinalclass ThreadFactoryImplimplementsThreadFactory{
        public ThreadnewThread(Runnable r){
            Thread thread = newThread(r);
            thread.setDaemon(true);
            return thread;
        }
    }
    private staticExecutorService service=Executors.newCachedThreadPool(new ThreadFactoryImpl());
    protected abstract T createInstance();
    protected abstractClass<?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

packageorg.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：[e-mail]
 * @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 StringgetDate(){
        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 staticvoid 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已成为毋庸置疑的核心标准。

 

synchronized 加 lock（锁）用于互斥条件（注意：这个锁必须是同一个对象，否则不可以达到互斥）

 

另两个帮助学习网址：http://www.cnblogs.com/sarafill/archive/2011/05/18/2049461.html

                  http://blog.csdn.net/zhaonanemail/article/details/7060765