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

拼搏现实的明天。 2022-08-07 02:47 155阅读 0赞

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

本文来自CSDN博客，转载请标明出处：[http://blog.csdn.net/cping1982/archive/2007/12/12/1931539.aspx][http_blog.csdn.net_cping1982_archive_2007_12_12_1931539.aspx]

[ceponline_yahoo.com.cn]: mailto:ceponline@yahoo.com.cn
[http_blog.csdn.net_cping1982_archive_2007_12_12_1931539.aspx]: http://blog.csdn.net/cping1982/archive/2007/12/12/1931539.aspx