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



本文转自 cping 51CTO博客,原文链接:http://blog.51cto.com/cping1982/130173

相关文章
|
2天前
|
负载均衡 NoSQL Java
|
20小时前
|
安全 Java 开发者
探索Java内存模型:可见性、有序性和并发
在Java的并发编程领域中,内存模型扮演了至关重要的角色。本文旨在深入探讨Java内存模型的核心概念,包括可见性、有序性和它们对并发实践的影响。我们将通过具体示例和底层原理分析,揭示这些概念如何协同工作以确保跨线程操作的正确性,并指导开发者编写高效且线程安全的代码。
|
3天前
|
安全 算法 Java
Java 中的并发控制:锁与线程安全
在 Java 的并发编程领域,理解并正确使用锁机制是实现线程安全的关键。本文深入探讨了 Java 中各种锁的概念、用途以及它们如何帮助开发者管理并发状态。从内置的同步关键字到显式的 Lock 接口,再到原子变量和并发集合,本文旨在为读者提供一个全面的锁和线程安全的知识框架。通过具体示例和最佳实践,我们展示了如何在多线程环境中保持数据的一致性和完整性,同时避免常见的并发问题,如死锁和竞态条件。无论你是 Java 并发编程的新手还是有经验的开发者,这篇文章都将帮助你更好地理解和应用 Java 的并发控制机制。
|
12天前
|
设计模式 安全 Java
Java面试题:设计模式如单例模式、工厂模式、观察者模式等在多线程环境下线程安全问题,Java内存模型定义了线程如何与内存交互,包括原子性、可见性、有序性,并发框架提供了更高层次的并发任务处理能力
Java面试题:设计模式如单例模式、工厂模式、观察者模式等在多线程环境下线程安全问题,Java内存模型定义了线程如何与内存交互,包括原子性、可见性、有序性,并发框架提供了更高层次的并发任务处理能力
28 1
|
12天前
|
安全 算法 Java
Java面试题:如何使用并发集合,例如ConcurrentHashMap?
Java面试题:如何使用并发集合,例如ConcurrentHashMap?
22 1
|
12天前
|
设计模式 存储 安全
Java面试题:设计一个线程安全的单例类并解释其内存占用情况?使用Java多线程工具类实现一个高效的线程池,并解释其背后的原理。结合观察者模式与Java并发框架,设计一个可扩展的事件处理系统
Java面试题:设计一个线程安全的单例类并解释其内存占用情况?使用Java多线程工具类实现一个高效的线程池,并解释其背后的原理。结合观察者模式与Java并发框架,设计一个可扩展的事件处理系统
23 1
|
12天前
|
设计模式 安全 Java
Java面试题:请解释Java中的线程池以及为什么要使用线程池?请解释Java中的内存模型以及如何避免内存泄漏?请解释Java中的并发工具包以及如何实现一个简单的线程安全队列?
Java面试题:请解释Java中的线程池以及为什么要使用线程池?请解释Java中的内存模型以及如何避免内存泄漏?请解释Java中的并发工具包以及如何实现一个简单的线程安全队列?
16 1
|
12天前
|
设计模式 缓存 安全
Java面试题:工厂模式与内存泄漏防范?线程安全与volatile关键字的适用性?并发集合与线程池管理问题
Java面试题:工厂模式与内存泄漏防范?线程安全与volatile关键字的适用性?并发集合与线程池管理问题
16 1
|
3天前
|
算法 Java 调度
Java中的并发与性能优化策略
在面对日益复杂的业务场景时,Java开发者常常遇到并发处理和性能瓶颈的挑战。本文深入探讨了Java并发机制的核心原理,并提供了针对性能提升的实用策略。通过分析线程池、同步机制以及JVM调优等技术的应用,文章旨在为读者提供一套系统的Java并发解决方案和性能优化方法论。
|
12天前
|
设计模式 存储 缓存
Java面试题:结合设计模式与并发工具包实现高效缓存;多线程与内存管理优化实践;并发框架与设计模式在复杂系统中的应用
Java面试题:结合设计模式与并发工具包实现高效缓存;多线程与内存管理优化实践;并发框架与设计模式在复杂系统中的应用
15 0