Chinaunix首页 | 论坛 | 博客
  • 博客访问: 1459765
  • 博文数量: 187
  • 博客积分: 10375
  • 博客等级: 上将
  • 技术积分: 3127
  • 用 户 组: 普通用户
  • 注册时间: 2006-03-07 10:58
文章分类

全部博文(187)

文章存档

2013年(1)

2012年(8)

2011年(28)

2010年(36)

2009年(47)

2008年(67)

我的朋友

分类: Java

2008-11-30 21:28:38

对于多线程编程还不太了解,拿别人的文章来学习一下。
 
在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;
/**
 *

Title: LoonFramework


 *

Description:利用Future模式进行处理


 *

Copyright: Copyright (c) 2007


 *

Company: LoonFramework


 * @author chenpeng
 * @email:ceponline@yahoo.com.cn
 * @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;
/**
 *

Title: LoonFramework


 *

Description:


 *

Copyright: Copyright (c) 2007


 *

Company: LoonFramework


 * @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已成为毋庸置疑的核心标准。
阅读(6290) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~