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

cping1982

关注

原创最新推荐文章于 2025-03-19 19:46:40 发布 5.9w 阅读 AI 写同款· GEO 优化 ›

（十一）java并发编程--java.util.concurrent.Callable 本篇文章用到了java并发包中的这几个接口和类 java.util.concurrent.Callable java.util.concurrent.FutureTask java.util.concurrent.Future java.util.concurrent.Executor1.使用Callable + FutureTask方式,代码如下所示。阅读详情

我们都知道，在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模式进行处理

* 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:

* 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已成为毋庸置疑的核心标准。