`
dowhathowtodo
  • 浏览: 805658 次
文章分类
社区版块
存档分类
最新评论

浅谈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: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;

/** *//**
* <p>Title: LoonFramework</p>
* <p>Description:</p>
* <p>Copyright: Copyright (c) 2007</p>
* <p>Company: LoonFramework</p>
* @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已成为毋庸置疑的核心标准。

本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/cping1982/archive/2007/12/12/1931539.aspx

分享到:
评论

相关推荐

    浅谈java.util.concurrent包中的线程池和消息队列

    java.util.concurrent包是JDK5.0(JDK1.5更名后)引入的高级并发特性,主要包括原子量、并发集合、同步器、可重入锁,并对线程池的构造提供了强力的支持。该包充分利用了现代多处理器和多核心系统的功能,以编写大...

    浅谈Java中的几种随机数

    对于更高级的并发环境,Java 7引入了一个新的并发随机数生成器:java.util.concurrent.ThreadLocalRandom。这个类在内部使用了线程局部变量来避免多线程之间的竞争,相比于使用Random类,它在生成大量随机数时可以...

    浅谈Java多线程处理中Future的妙用(附源码)

    "浅谈Java多线程处理中Future的妙用" 在Java多线程处理中,Future是一个非常重要的概念,它可以帮助我们更好地处理并发任务。Future是一个未来对象,里面保存着线程处理结果,它像一个提货凭证,拿着它你可以随时去...

    浅谈java中的几种随机数

    不过,对于极度并发的场景,`java.util.concurrent.ThreadLocalRandom`类提供了更好的性能。`ThreadLocalRandom.current().nextInt(10)`不仅能保证每个线程拥有自己的随机数生成器,而且执行速度更快。这个类是Java ...

    浅谈Java的多线程机制.pdf

    ### 浅谈Java的多线程机制 #### 一、引言 随着计算机技术的不断发展,编程模型变得越来越复杂和多样化。多线程编程模型作为目前计算机系统架构中的一个重要组成部分,其重要性日益凸显。特别是在X86架构的硬件成为...

    Java分布式应用学习笔记06浅谈并发加锁机制分析

    ### Java分布式应用学习笔记06浅谈并发加锁机制分析 #### 1. 前言 在深入探讨Java中的并发加锁机制之前,我们有必要回顾一下多线程环境下的一些基本概念和技术。之前的多线程调度、并发调度以及线程加锁安全等内容...

    浅谈Java线程的生命周期——北大青鸟佳音旗舰.docx

    在Java编程中,线程是程序执行的最小单元,它们允许并发处理多个任务,提高程序的效率。本文将深入探讨Java线程的生命周期,包括创建、启动、结束以及线程的协作和调度。 首先,创建Java线程有两种主要方式:直接...

    AtomicInteger 浅谈

    《AtomicInteger 浅谈》 在Java编程中,原子性操作是并发编程中非常关键的一环,它确保了在多线程环境下数据的正确性和一致性。AtomicInteger是Java并发包java.util.concurrent.atomic中的一个类,提供了对单个整型...

    浅谈Java 并发的底层实现

    Java并发编程是优化程序性能的关键技术之一,尤其是在处理高并发量的应用中。本文将深入探讨Java并发的底层实现,帮助开发者更好地理解和应用并发技术。 首先,我们要明确并发编程的初衷是为了提升程序的运行效率,...

    浅谈Java中随机数的几种实现方式

    然而,考虑到线程安全的开销,`java.util.concurrent.ThreadLocalRandom`在Java 7中被引入,它提供了一个更为高效的线程局部随机数生成器。使用`ThreadLocalRandom.current().nextInt(10)`可以得到0到9之间的随机...

    浅谈Java中生产者与消费者问题的演变

    为了解决这些问题,Java 5引入了`java.util.concurrent`包,提供了更高级的并发工具,如`BlockingQueue`。 `BlockingQueue`接口及其实现(如`ArrayBlockingQueue`、`LinkedBlockingQueue`等)提供了一种线程安全的...

    浅谈在Java中使用Callable、Future进行并行编程

    Callable接口是Java并发库中的一个关键接口,位于`java.util.concurrent`包下。Callable接口与Runnable接口类似,但它具有一个泛型方法`call()`,该方法在执行时会返回一个结果,并可能抛出异常。Callable接口的定义...

    浅谈java常用的几种线程池比较

    Java的`util.concurrent`包提供了一些线程池的实现,如`ThreadPoolExecutor`,它允许自定义核心线程数、最大线程数、线程存活时间、任务队列等参数,以适应不同场景的需求。通过合理配置这些参数,可以有效管理和...

    浅谈java线程中生产者与消费者的问题

    - **阻塞队列**:在实际开发中,Java的`java.util.concurrent`包提供了阻塞队列(如`BlockingQueue`),它内置了线程同步机制,可以更方便地解决生产者与消费者问题,简化代码。 - **信号量**:`Semaphore`类可以...

    浅谈Android中线程池的管理

    在Android中,可以使用`java.util.concurrent`包下的ThreadPoolExecutor类来创建线程池。 创建线程池的基本步骤如下: 1. 定义核心线程数:线程池始终存在的最小线程数。 2. 定义最大线程数:线程池能容纳的最大...

Global site tag (gtag.js) - Google Analytics