- 浏览: 749277 次
- 性别:
- 来自: 杭州
文章分类
最新评论
-
webcover:
最新的中文网络记事本: 破笔记
网络记事本:http://w ...
五个最佳的免费网络记事本 -
fred_nxh:
很好,长见识了
java中堆(heap)和堆栈(stack)有什么区别 -
efeige:
兄弟,请问一下,为什么我的2003系统 网站属性 里面没有“服 ...
启用IIS Gzip 页面压缩技术 加速网页的浏览速度 -
252401762:
同样的问题啊,不知道楼主是否已经转做售前了
售前和 开发的选择 -
yuan:
膜拜玩静电的现在呢?
来回顾一下,当年的“发烧史”吧:
DougLea的util.concurrent
包除了包含许多其他有用的并发构造块之外,还包含了一些主要集合类型List
和Map
的高性能的、线程安全的实现。在本月的 Java理论与实践中,BrianGoetz向您展示了用ConcurrentHashMap
替换Hashtable
或synchronizedMap
,将有多少并发程序获益。您可以在本文的 论坛中与作者以及其他读者共享您的想法(您也可以点击文章顶部或者底部的 讨论进入论坛)。
在Java类库中出现的第一个关联的集合类是 Hashtable
,它是JDK 1.0的一部分。 Hashtable
提供了一种易于使用的、线程安全的、关联的map功能,这当然也是方便的。然而,线程安全性是凭代价换来的―― Hashtable
的所有方法都是同步的。此时,无竞争的同步会导致可观的性能代价。 Hashtable
的后继者 HashMap
是作为JDK1.2中的集合框架的一部分出现的,它通过提供一个不同步的基类和一个同步的包装器 Collections.synchronizedMap
,解决了线程安全性问题。通过将基本的功能从线程安全性中分离开来, Collections.synchronizedMap
允许需要同步的用户可以拥有同步,而不需要同步的用户则不必为同步付出代价。
Hashtable
和 synchronizedMap
所采取的获得同步的简单方法(同步 Hashtable
中或者同步的 Map
包装器对象中的每个方法)有两个主要的不足。首先,这种方法对于可伸缩性是一种障碍,因为一次只能有一个线程可以访问hash表。同时,这样仍不足以提供真正的线程安全性,许多公用的混合操作仍然需要额外的同步。虽然诸如 get()
和 put()
之类的简单操作可以在不需要额外同步的情况下安全地完成,但还是有一些公用的操作序列,例如迭代或者put-if-absent(空则放入),需要外部的同步,以避免数据争用。
同步的集合包装器 synchronizedMap
和 synchronizedList
,有时也被称作 有条件地线程安全――所有单个的操作都是线程安全的,但是多个操作组成的操作序列却可能导致数据争用,因为在操作序列中控制流取决于前面操作的结果。 清单1中第一片段展示了公用的put-if-absent语句块――如果一个条目不在 Map
中,那么添加这个条目。不幸的是,在 containsKey()
方法返回到 put()
方法被调用这段时间内,可能会有另一个线程也插入一个带有相同键的值。如果您想确保只有一次插入,您需要用一个对 Map m
进行同步的同步块将这一对语句包装起来。
清单1中其他的例子与迭代有关。在第一个例子中, List.size()
的结果在循环的执行期间可能会变得无效,因为另一个线程可以从这个列表中删除条目。如果时机不得当,在刚好进入循环的最后一次迭代之后有一个条目被另一个线程删除了,则 List.get()
将返回 null
,而 doSomething()
则很可能会抛出一个 NullPointerException
异常。那么,采取什么措施才能避免这种情况呢?如果当您正在迭代一个 List
时另一个线程也可能正在访问这个 List
,那么在进行迭代时您必须使用一个 synchronized
块将这个 List
包装起来,在 List
1 上同步,从而锁住整个 List
。这样做虽然解决了数据争用问题,但是在并发性方面付出了更多的代价,因为在迭代期间锁住整个 List
会阻塞其他线程,使它们在很长一段时间内不能访问这个列表。
集合框架引入了迭代器,用于遍历一个列表或者其他集合,从而优化了对一个集合中的元素进行迭代的过程。然而,在 java.util
集合类中实现的迭代器极易崩溃,也就是说,如果在一个线程正在通过一个 Iterator
遍历集合时,另一个线程也来修改这个集合,那么接下来的 Iterator.hasNext()
或 Iterator.next()
调用将抛出 ConcurrentModificationException
异常。就拿刚才这个例子来讲,如果想要防止出现 ConcurrentModificationException
异常,那么当您正在进行迭代时,您必须使用一个在 List l
上同步的 synchronized
块将该 List
包装起来,从而锁住整个 List
。(或者,您也可以调用 List.toArray()
,在不同步的情况下对数组进行迭代,但是如果列表比较大的话这样做代价很高)。
Map m = Collections.synchronizedMap(new HashMap()); List l = Collections.synchronizedList(new ArrayList()); // put-if-absent idiom -- contains a race condition // may require external synchronization if (!map.containsKey(key)) map.put(key, value); // ad-hoc iteration -- contains race conditions // may require external synchronization for (int i=0; i<list.size(); i++) { doSomething(list.get(i)); } // normal iteration -- can throw ConcurrentModificationException // may require external synchronization for (Iterator i=list.iterator(); i.hasNext(); ) { doSomething(i.next()); } |
synchronizedList
和 synchronizedMap
提供的有条件的线程安全性也带来了一个隐患 ――
开发者会假设,因为这些集合都是同步的,所以它们都是线程安全的,这样一来他们对于正确地同步混合操作这件事就会疏忽。其结果是尽管表面上这些程序在负载较轻的时候能够正常工作,但是一旦负载较重,它们就会开始抛出 NullPointerException
或 ConcurrentModificationException
。
|
|
可伸缩性指的是一个应用程序在工作负载和可用处理资源增加时其吞吐量的表现情况。一个可伸缩的程序能够通过使用更多的处理器、内存或者I/O带宽来相应地处理更大的工作负载。锁住某个共享的资源以获得独占式的访问这种做法会形成可伸缩性瓶颈――它使其他线程不能访问那个资源,即使有空闲的处理器可以调用那些线程也无济于事。为了取得可伸缩性,我们必须消除或者减少我们对独占式资源锁的依赖。
同步的集合包装器以及早期的 Hashtable
和 Vector
类带来的更大的问题是,它们在单个的锁上进行同步。这意味着一次只有一个线程可以访问集合,如果有一个线程正在读一个 Map
,那么所有其他想要读或者写这个 Map
的线程就必须等待。最常见的 Map
操作, get()
和 put()
,可能比表面上要进行更多的处理――当遍历一个hash表的bucket以期找到某一特定的key时, get()
必须对大量的候选bucket调用 Object.equals()
。如果key类所使用的 hashCode()
函数不能将value均匀地分布在整个hash表范围内,或者存在大量的hash冲突,那么某些bucket链就会比其他的链长很多,而遍历一个长的hash链以及对该hash链上一定百分比的元素调用 equals()
是一件很慢的事情。在上述条件下,调用 get()
和 put()
的代价高的问题不仅仅是指访问过程的缓慢,而且,当有线程正在遍历那个hash链时,所有其他线程都被锁在外面,不能访问这个 Map
。
(哈希表根据一个叫做hash的数字关键字(key)将对象存储在bucket中。hash value是从对象中的值计算得来的一个数字。每个不同的hash value都会创建一个新的bucket。要查找一个对象,您只需要计算这个对象的hash value并搜索相应的bucket就行了。通过快速地找到相应的bucket,就可以减少您需要搜索的对象数量了。译者注)
get()
执行起来可能会占用大量的时间,而在某些情况下,前面已经作了讨论的有条件的线程安全性问题会让这个问题变得还要糟糕得多。 清单1 中演示的争用条件常常使得对单个集合的锁在单个操作执行完毕之后还必须继续保持一段较长的时间。如果您要在整个迭代期间都保持对集合的锁,那么其他的线程就会在锁外停留很长的一段时间,等待解锁。
Map
在服务器应用中最常见的应用之一就是实现一个 cache。
服务器应用可能需要缓存文件内容、生成的页面、数据库查询的结果、与经过解析的XML文件相关的DOM树,以及许多其他类型的数据。cache的主要用途是重用前一次处理得出的结果以减少服务时间和增加吞吐量。cache工作负载的一个典型的特征就是检索大大多于更新,因此(理想情况下)cache能够提供非常好的 get()
性能。不过,使用会妨碍性能的cache还不如完全不用cache。
如果使用 synchronizedMap
来实现一个cache,那么您就在您的应用程序中引入了一个潜在的可伸缩性瓶颈。因为一次只有一个线程可以访问 Map
,这些线程包括那些要从 Map
中取出一个值的线程以及那些要将一个新的 (key, value)
对插入到该map中的线程。
提高 HashMap
的并发性同时还提供线程安全性的一种方法是废除对整个表使用一个锁的方式,而采用对hash表的每个bucket都使用一个锁的方式(或者,更常见的是,使用一个锁池,每个锁负责保护几个bucket)。这意味着多个线程可以同时地访问一个 Map
的不同部分,而不必争用单个的集合范围的锁。这种方法能够直接提高插入、检索以及移除操作的可伸缩性。不幸的是,这种并发性是以一定的代价换来的――这使得对整个集合进行操作的一些方法(例如 size()
或 isEmpty()
)的实现更加困难,因为这些方法要求一次获得许多的锁,并且还存在返回不正确的结果的风险。然而,对于某些情况,例如实现cache,这样做是一个很好的折衷――因为检索和插入操作比较频繁,而 size()
和 isEmpty()
操作则少得多。
|
|
util.concurrent
包中的 ConcurrentHashMap
类(也将出现在JDK 1.5中的 java.util.concurrent
包中)是对 Map
的线程安全的实现,比起 synchronizedMap
来,它提供了好得多的并发性。多个读操作几乎总可以并发地执行,同时进行的读和写操作通常也能并发地执行,而同时进行的写操作仍然可以不时地并发进行(相关的类也提供了类似的多个读线程的并发性,但是,只允许有一个活动的写线程) 。ConcurrentHashMap
被设计用来优化检索操作;实际上,成功的 get()
操作完成之后通常根本不会有锁着的资源。要在不使用锁的情况下取得线程安全性需要一定的技巧性,并且需要对Java内存模型(Java Memory Model)的细节有深入的理解。 ConcurrentHashMap
实现,加上 util.concurrent
包的其他部分,已经被研究正确性和线程安全性的并发专家所正视。在下个月的文章中,我们将看看 ConcurrentHashMap
的实现的细节。
ConcurrentHashMap
通过稍微地松弛它对调用者的承诺而获得了更高的并发性。检索操作将可以返回由最近完成的插入操作所插入的值,也可以返回在步调上是并发的插入操作所添加的值(但是决不会返回一个没有意义的结果)。由 ConcurrentHashMap.iterator()
返回的 Iterators
将每次最多返回一个元素,并且决不会抛出 ConcurrentModificationException
异常,但是可能会也可能不会反映在该迭代器被构建之后发生的插入操作或者移除操作。在对集合进行迭代时,不需要表范围的锁就能提供线程安全性。在任何不依赖于锁整个表来防止更新的应用程序中,可以使用 ConcurrentHashMap
来替代 synchronizedMap
或 Hashtable
。
上述改进使得 ConcurrentHashMap
能够提供比 Hashtable
高得多的可伸缩性,而且,对于很多类型的公用案例(比如共享的cache)来说,还不用损失其效率。
表 1对 Hashtable
和 ConcurrentHashMap
的可伸缩性进行了粗略的比较。在每次运行过程中, n 个线程并发地执行一个死循环,在这个死循环中这些线程从一个 Hashtable
或者 ConcurrentHashMap
中检索随机的key value,发现在执行 put()
操作时有80%的检索失败率,在执行操作时有1%的检索成功率。测试所在的平台是一个双处理器的Xeon系统,操作系统是Linux。数据显示了10,000,000次迭代以毫秒计的运行时间,这个数据是在将对 ConcurrentHashMap的
操作标准化为一个线程的情况下进行统计的。您可以看到,当线程增加到多个时, ConcurrentHashMap
的性能仍然保持上升趋势,而 Hashtable
的性能则随着争用锁的情况的出现而立即降了下来。
比起通常情况下的服务器应用,这次测试中线程的数量看上去有点少。然而,因为每个线程都在不停地对表进行操作,所以这与实际环境下使用这个表的更多数量的线程的争用情况基本等同。
表 1.Hashtable 与 ConcurrentHashMap在可伸缩性方面的比较
线程数 | ConcurrentHashMap | Hashtable |
1 | 1.00 | 1.03 |
2 | 2.59 | 32.40 |
4 | 5.58 | 78.23 |
8 | 13.21 | 163.48 |
16 | 27.58 | 341.21 |
32 | 57.27 | 778.41 |
|
|
在那些遍历操作大大地多于插入或移除操作的并发应用程序中,一般用 CopyOnWriteArrayList
类替代 ArrayList
。如果是用于存放一个侦听器(listener)列表,例如在AWT或Swing应用程序中,或者在常见的JavaBean中,那么这种情况很常见(相关的 CopyOnWriteArraySet
使用一个 CopyOnWriteArrayList
来实现 Set
接口)。
如果您正在使用一个普通的 ArrayList
来存放一个侦听器列表,那么只要该列表是可变的,而且可能要被多个线程访问,您就必须要么在对其进行迭代操作期间,要么在迭代前进行的克隆操作期间,锁定整个列表,这两种做法的开销都很大。当对列表执行会引起列表发生变化的操作时, CopyOnWriteArrayList
并不是为列表创建一个全新的副本,它的迭代器肯定能够返回在迭代器被创建时列表的状态,而不会抛出 ConcurrentModificationException
。在对列表进行迭代之前不必克隆列表或者在迭代期间锁定列表,因为迭代器所看到的列表的副本是不变的。换句话说, CopyOnWriteArrayList
含有对一个不可变数组的一个可变的引用,因此,只要保留好那个引用,您就可以获得不可变的线程安全性的好处,而且不用锁定列表。
|
|
同步的集合类 Hashtable
和 Vector
,以及同步的包装器类 Collections.synchronizedMap
和 Collections.synchronizedList
,为 Map
和 List
提供了基本的有条件的线程安全的实现。然而,某些因素使得它们并不适用于具有高度并发性的应用程序中――它们的集合范围的单锁特性对于可伸缩性来说是一个障碍,而且,很多时候还必须在一段较长的时间内锁定一个集合,以防止出现 ConcurrentModificationException
s异常。 ConcurrentHashMap
和 CopyOnWriteArrayList
实现提供了更高的并发性,同时还保住了线程安全性,只不过在对其调用者的承诺上打了点折扣。 ConcurrentHashMap
和 CopyOnWriteArrayList
并不是在您使用 HashMap
或 ArrayList
的任何地方都一定有用,但是它们是设计用来优化某些特定的公用解决方案的。许多并发应用程序将从对它们的使用中获得好处。
发表评论
-
ocx插件插入网页实现自动更新与安装注册
2010-07-27 16:17 6573ocx插件插入网页实现 ... -
JIRA
2010-04-02 16:28 1176JIRA 百科名片 JIRA是集项目计划、任务分配、需求管 ... -
ArrayList和LinkedList的用法区别
2010-03-17 10:58 1834ArrayList和LinkedList的用法区别 (2 ... -
Java 中Vector、ArrayList和LinkedList 的区别时间
2010-03-17 10:25 1657Java 中Vector、ArrayList和LinkedLi ... -
多层架构的Web开发框架模型
2010-03-14 00:31 1909摘要:在经典的J2EE四层体系结构的基础上增加数据持久层,提出 ... -
Java语言编码规范(Java Code Conventions
2010-03-08 01:17 7501 介绍(Introduction)1.1 为什么要有编码规范 ... -
IT 的规划
2010-02-21 21:07 740本文说的这位网友,在I ... -
记忆学
2010-02-10 00:50 633http://bbs.jiyifa.cn/read.php?t ... -
java析构函数替代者finalize()解说
2010-01-21 22:18 2496java析构函数替代者finali ... -
Java的GC机制总结(0) ---finalize()方法
2010-01-21 22:00 1175其实了解JAVA的人,都知道JAVA的GC机制是其的一大优点, ... -
Java认证考试
2010-01-14 12:30 807Java认证考试 关于Java方面,Sun推出四项认证:Su ... -
集合框架
2010-01-13 23:24 614java 集合框架 对象的集合 如果程序的 ... -
Java集合框架使用总结
2010-01-13 21:31 630Java集合框架使用总结 ... -
关于JAVA中的线程安全
2010-01-13 10:34 1509关于JAVA中的线程安全 ... -
java main 主函数
2010-01-10 14:28 2289java主函数一般定义如下:public static ... -
java新式for循环
2009-12-29 15:51 756java新式for循环 2008-08-04 13:48:2 ... -
2009年的Java技术发展趋势展望
2009-11-08 21:28 728已经有14岁的Java在日新月异的IT技术领域内不算年轻,但它 ... -
MyEclipse要注册
2009-11-07 18:37 1662yEclipse怎么注册都不知道。我说他没有注册,他硬要说已经 ... -
浅谈设计模式在JAVA中的具体运用
2009-10-27 23:32 915浅谈设计模式在JAVA ... -
BBSCS 代码阅读
2009-10-26 18:38 642发布的时候,出现乱码================== 如何 ...
相关推荐
本文介绍了在Java类库中出现的第一个关联的集合类是Hashtable,它是JDK 1.0的一部分。Hashtable提供了一种易于使用的、线程安全的、关联的map功能,这当然也是方便的。然而,线程安全性是凭代价换来的―― Hashtable...
本文介绍了当项目中需要XML解析器、文本索引程序和搜索...util.concurrent是JSR 166的切入点,它将带来一组并发性的实用程序,这些实用程序将成为 JDK 1.5中的java.util.concurrent包,但您不必等到那时侯才能使用它。
本文介绍了在Java理论与实践中,几种比较简单的非阻塞算法的工作方式。在不只一个线程访问一个互斥的变量时,所有线程都必须使用同步,否则就可能会发生一些非常糟糕的事情。Java语言中主要的同步手段就是...
本文还介绍了JMM有一些严重的缺点,如果正确地编写并发的类太困难的话,那么许多并发的类不能按预期工作,并且这是平台中的一个缺点。在不破坏在旧的内存模型下正确同步的任何代码的同时,我们可以创建一个与大多数...
本文介绍了要使用多处理器系统的功能,通常需要使用多线程构造应用程序。...然后,java.util.concurrent中的类基于这些低级原子变量工具构建,为它们提供比以前执行相似功能的类更显著的可伸缩性优点。
虽然许多Java平台提供了比JMM所要求的更强的保证,但是JMM中的漏洞使得无法容易地编写可以在任何平台上运行的并发Java程序。JSR 133显著增强了volatile的语义,这样就可以可靠地使用volatile标志表明程序状态被另一...
并简单概述了老对象和年轻对象、分代收集、小的收集、代间引用、跟踪代间引用、卡片标记、JDK 1.4.1 默认收集器、并行收集器和并发收集器、微调垃圾收集器等理论或技术。得出:随着JVM的发展,默认垃圾收集器变得...
本文定义了什么是事务,列举了事务的基本特性,并探讨了Java事务服务和J2EE容器如何合作为事务提供对 J2EE 组件的透明支持。在本文中,我们将讨论事务的划分和隔离这个主题。为EJB组件定义事务划分和隔离属性的职责...
在简化与平台无关的并发类的开发的同时,它决没有使并发类的编写工作变得更繁琐,只是使它变得更容易了。本文还简单介绍和比较了ReentrantLock和synchronized,以及在什么时候选择用ReentrantLock代替synchronized。
java 并发编程实践java 并发编程实践java 并发编程实践java 并发编程实践java 并发编程实践
Java 5以及6在开发并发程序中取得了显著的进步,提高了Java虚拟机的性能以及并发类的可伸缩性,并加入了丰富的新并发构建块。在《JAVA并发编程实践》中,这些便利工具的创造者不仅解释了它们究竟如何工作、如何使用...
Java 5以及6在开发并发程序中取得了显著的进步,提高了Java虚拟机的性能以及并发类的可伸缩性,并加入了丰富的新并发构建块。在《JAVA并发编程实践》中,这些便利工具的创造者不仅解释了它们究竟如何工作、如何使用...
英文版:Java Concurrency in Practice 内容简介 《JAVA并发编程实践》随着多核处理器的普及,使用并发成为构建高性能应用程序的关键。Java 5以及6在开发并发程序中取得了显著的进步,提高了Java虚拟机的性能以及...
并发理论, 并发关键字, Lock 体系, 原子操作类, 发容器 & 并发工具, 线程池, 并发实践 Java是一种面向对象的编程语言,由Sun Microsystems于1995年推出。它是一种跨平台的语言,意味着可以在不同的操作系统上...
java并发编程实践java并发编程实践java并发编程实践java并发编程实践
JAVA 高并发 实践书籍 附目录JAVA 高并发 实践书籍 附目录JAVA 高并发 实践书籍 附目录
java并发编程与实践是java高并发的分析文档,分析并介绍了高并发的解决方案。
Java 5以及6在开发并发程序中取得了显著的进步,提高了Java虚拟机的性能以及并发类的可伸缩性,并加入了丰富的新并发构建块。在《JAVA并发编程实践》中,这些便利工具的创造者不仅解释了它们究竟如何工作、如何使用...
java并发编程实践
该压缩包里含有两本pdf书籍:effictive java第二版和java并发实战,希望能对大家提升技术有所帮助。