java.util.concurrent中的CopyOnWrite容器(转载)

今天在CoolShell上看到有人在介绍CopyOnWrite容器,突然一看觉得非常高大上,然后突然一看原来是java.util.concurrent中早就实现好的类,瞬间觉得自己j2se白学了,连这些成熟的实现都不知道。但是仔细一想还是在工作中没有这样的应用场景,所以导致好多东西都弱化了。

言归正传,看看人家是怎么讲CopyOnWrite容器的吧。

以下内容转载自酷壳:

Copy-On-Write简称COW,是一种用于程序设计中的优化策略。其基本思路是,从一开始大家都在共享同一个内容,当某个人想要修改这个内容的时候,才会真正把内容Copy出去形成一个新的内容然后再改,这是一种延时懒惰策略。从JDK1.5开始Java并发包里提供了两个使用CopyOnWrite机制实现的并发容器,它们是CopyOnWriteArrayList和CopyOnWriteArraySet。CopyOnWrite容器非常有用,可以在非常多的并发场景中使用到。

什么是CopyOnWrite容器

CopyOnWrite容器即写时复制的容器。通俗的理解是当我们往一个容器添加元素的时候,不直接往当前容器添加,而是先将当前容器进行Copy,复制出一个新的容器,然后新的容器里添加元素,添加完元素之后,再将原容器的引用指向新的容器。这样做的好处是我们可以对CopyOnWrite容器进行并发的读,而不需要加锁,因为当前容器不会添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想,读和写不同的容器。

CopyOnWriteArrayList的实现原理

在使用CopyOnWriteArrayList之前,我们先阅读其源码了解下它是如何实现的。以下代码是向ArrayList里添加元素,可以发现在添加的时候是需要加锁的,否则多线程写的时候会Copy出N个副本出来。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public boolean add(T e) {?
????final ReentrantLock lock = this.lock;?
????lock.lock();?
????try {?
????
????????Object[] elements = getArray();?
????
????????int len = elements.length;?
????????// 复制出新数组?
????
????????Object[] newElements = Arrays.copyOf(elements, len + 1);?
????????// 把新元素添加到新数组里?
????
????????// 把原数组引用指向新数组????????? newElements[len] = e;?
????
????????setArray(newElements);?
????
????????return true;?
????
????} finally {?
????
????????lock.unlock();?
????
????}?
????
}?
????
final void setArray(Object[] a) {?
????array = a;?
}

读的时候不需要加锁,如果读的时候有多个线程正在向ArrayList添加数据,读还是会读到旧的数据,因为写的时候不会锁住旧的ArrayList。

1
public E get(int index) {???? return get(getArray(), index); }

JDK中并没有提供CopyOnWriteMap,我们可以参考CopyOnWriteArrayList来实现一个,基本代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.util.Collection;?
import java.util.Map;?
import java.util.Set;??
??
?public class CopyOnWriteMap<K, V> implements Map<K,V>,Cloneable?
{?? private volatile Map<K, V> internalMap;??????
????public CopyOnWriteMap() {????????
??????????internalMap = new HashMap<K, V>();???
?????}??????
?public V put(K key, V value) {???????????
??????synchronized (this) {???????????
?????Map<K, V> newMap = new HashMap<K, V>(internalMap);?????????????
?????V val = newMap.put(key, value);????????????
??????internalMap = newMap;????????????
?????????return val;???????? }???? }??????
?public V get(Object key) {?????????
??????return internalMap.get(key);???? }??????
?public void putAll(Map<? extends K, ? extends V> newData)? {???????? synchronized (this) {????????????
????????????????Map<K, V> newMap = new HashMap<K,V>????????? (internalMap);???????????? newMap.putAll(newData);???????????? internalMap = newMap;???????? }???? } }

CopyOnWrite的应用场景

CopyOnWrite并发容器用于读多写少的并发场景。比如白名单,黑名单,商品类目的访问和更新场景,假如我们有一个搜索网站,用户在这个网站的搜索框中,输入关键字搜索内容,但是某些关键字不允许被搜索。这些不能被搜索的关键字会被放在一个黑名单当中,黑名单每天晚上更新一次。当用户搜索时,会检查当前关键字在不在黑名单当中,如果在,则提示不能搜索。实现代码如下:

 

packagecom.ifeve.book;?
?
importjava.util.Map;?
?
importcom.ifeve.book.forkjoin.CopyOnWriteMap;?
?
/**?
?*?黑名单服务?
?*?
?*?@author?fangtengfei?
?*?
?*/
publicclassBlackListServiceImpl?{?
?
????privatestaticCopyOnWriteMap<String,?Boolean>?blackListMap?=?newCopyOnWriteMap<String,?Boolean>(?
????????????1000);?
?
????publicstaticbooleanisBlackList(String?id)?{?
????????returnblackListMap.get(id)?==?null??false:?true;?
????}?
?
????publicstaticvoidaddBlackList(String?id)?{?
????????blackListMap.put(id,?Boolean.TRUE);?
????}?
?
????/**?
?????*?批量添加黑名单?
?????*?
?????*?@param?ids?
?????*/
????publicstaticvoidaddBlackList(Map<String,Boolean>?ids)?{?
????????blackListMap.putAll(ids);?
????}?
?

代码很简单,但是使用CopyOnWriteMap需要注意两件事情:

1.?减少扩容开销。根据实际需要,初始化CopyOnWriteMap的大小,避免写时CopyOnWriteMap扩容的开销。

2.?使用批量添加。因为每次添加,容器每次都会进行复制,所以减少添加次数,可以减少容器的复制次数。如使用上面代码里的addBlackList方法。

CopyOnWrite的缺点

CopyOnWrite容器有很多优点,但是同时也存在两个问题,即内存占用问题和数据一致性问题。所以在开发的时候需要注意一下。

内存占用问题。因为CopyOnWrite的写时复制机制,所以在进行写操作的时候,内存里会同时驻扎两个对象的内存,旧的对象和新写入的对象(注意:在复制的时候只是复制容器里的引用,只是在写的时候会创建新对象添加到新容器里,而旧容器的对象还在使用,所以有两份对象内存)。如果这些对象占用的内存比较大,比如说200M左右,那么再写入100M数据进去,内存就会占用300M,那么这个时候很有可能造成频繁的Yong?GC和Full?GC。之前我们系统中使用了一个服务由于每晚使用CopyOnWrite机制更新大对象,造成了每晚15秒的Full?GC,应用响应时间也随之变长。

针对内存占用问题,可以通过压缩容器中的元素的方法来减少大对象的内存消耗,比如,如果元素全是10进制的数字,可以考虑把它压缩成36进制或64进制。或者不使用CopyOnWrite容器,而使用其他的并发容器,如ConcurrentHashMap

数据一致性问题。CopyOnWrite容器只能保证数据的最终一致性,不能保证数据的实时一致性。所以如果你希望写入的的数据,马上能读到,请不要使用CopyOnWrite容器。

关于C++的STL中,曾经也有过Copy-On-Write的玩法,参见陈皓的《C++?STL?String类中的Copy-On-Write》,后来,因为有很多线程安全上的事,就被去掉了。

 

Maven中的DependencyManagement和Dependencies

这几天新项目要用maven搭一个环境,在搭建的过程中发现有好多组件都依赖了很多其他的组件,而且有时候依赖的组件的版本还不一样,这样的话不知不觉就会因为包冲突发生一些莫名其妙的错误。今天发现maven中有个dependencyManagement貌似是解决这个问题的,所以查找了一下资料,现在将dependencyManagement和dependency比较如下:

dependencyManagement

Maven?使用dependencyManagement?元素来提供了一种管理依赖版本号的方式。通常会在一个组织或者项目的最顶层的父POM?中看到dependencyManagement?元素。使用pom.xml?中的dependencyManagement?元素能让所有在子项目中引用一个依赖而不用显式的列出版本号。Maven?会沿着父子层次向上走,直到找到一个拥有dependencyManagement?元素的项目,然后它就会使用在这个dependencyManagement?元素中指定的版本号。

这样做的好处就是:如果有多个子项目都引用同一样依赖,则可以避免在每个使用的子项目里都声明一个版本号,这样当想升级或切换到另一个版本时,只需要在顶层父容器里更新,而不需要一个一个子项目的修改?;另外如果某个子项目需要另外的一个版本,只需要声明version就可

使用dependencyManagement?可以避免不同的组件在依赖同一个组件的时候引用了不用的版本。

dependencies

相对于dependencyManagement,所有声明在dependencies里的依赖都会自动引入,并默认被所有的子项目继承。

?classifier

如果你要发布同样的代码,但是由于技术原因需要生成两个单独的构件,你就要使用一个分类器(classifier)。例如,如果你想要构建两个单独的构件成JAR,一个使用Java?1.4?编译器,另一个使用Java?6?编译器,你就可以使用分类器
来生成两个单独的JAR构件,它们有同样的groupId:artifactId:version组合。如果你的项目使用本地扩展类库,你可以使用分类器为每一个目标平台生成一个构件。分类器常用于打包构件的源码,JavaDoc?或者二进制集合。

旅行,写作,编程

本文的作者Alex?MacCaw

概括起来,今年到目前为止,我所做的事情包括:

    • 花了10个月的时间做世界环游,途经非洲,东南亚,澳洲,中南美洲里的17个国家和地区。这次旅行的主题就是冲浪和摄影。
    • 出席在香港,日本,美国和伦敦举行的会议
    • 启程时给O’Reilly出版公司写了一本书,书名叫做《JavaScript?Web?Applications
  • 另外写了一本关于CoffeeScript的书,很快就会由O’Reilly公司出版。
  • 写了大量的开源库,例如Spine,?Spine.Mobile,?GFX,?和?Juggernaut.
  • 筹划了一个创业公司的框架
  • 出席伦敦2011FOWA会议
  • 最后,我在Twitter公司找到了一份工作

那么,让我从一年前开始,那是2010年9月,我刚好从一个我合作创办的公司里出来,尽管这段经历是很有价值的,但无休无止的长时间苦干让我精疲力尽。我回到了英格兰,需要对未来做一些思考。我一直有一个梦想——移居美国(几年就好),所以,我在Google记事本上写了下面的话:

人生的选择:
  去纽约哥伦比亚大学深造
    坏处 - 非常昂贵,并不一定能学到什么真正有用的东西,无聊?
    好处 - 那是一个纽约的大学!
  写一本书,申请 01 签证
    坏处 - 需要大量的时间,有风险
    好处 - 对事业有好处,有趣
  等待。去纽约度一次假(3个月)。等待创业签证。
    很容易 - 不是那么有趣

也许选第二个,不行就选3?

最终我选择了2,我已经对JavaScript?web应用研究了很久,我要写一本这方面的书,为什么不边做环游世界的旅行、边写书呢?这也是我一个梦想呀。我从oneworld买了一份环游世界的机票(比你们想象的要便宜),决定下周去我的第一站,南非。

环游世界

如果你从来没有到过非洲,你应该去一次。那里的景色原始而美丽,对那些没有体验过这种景色的人,你很难用言语描绘明白。几年前我就喜欢上了南方,那时我在东海岸做了一个为期3个月的冲浪旅行。这次,我只有一个月的时间,穿越特兰斯凯,从开普敦到德班。当我在南非旅行时,我的写作也开始了,把早期向O’Reilly提交的书的框架里的数章填充了材料。

特兰斯凯是南非非常具有乡野特色的地方,到处是连绵的小山,一些小村庄和土堆的茅屋。他们仍然沿袭着酋长制度,有一个首领,大多数的当地人靠捕鱼为生。我们在高低不平的土路上颠了两天才到达我心仪的地方,一个美丽的海湾,叫做咖啡湾(Coffee?Bay)。在那里,我休整了一下,从网上下载了一些相关资料,为更远的海湾远征做准备。

我还清晰的记得我们走了数里地来到那个未开垦的海滩,我们从那些一个个被黄沙和小丘孤立的村庄穿行而过。有一个地方,我们要过一条大河,我们需要游过去,我把背包举过头顶,以免里面的相机和iPod遇到水。非洲是一个让你脱离尘世的地方,解放你的思想,重新认识人生最重要的东西是什么。

DSC_01643

下一站是香港,在那里,我度过了我的21岁生日,接着,我从陆路由新加坡到越南河内。很多人不相信香港70%的面积由自然公园覆盖,我徒步走了几条精彩的景观路线,非常的精彩壮观,比如:香港龙脊。有几天,我在boot.hk这个网站上闲逛,这是一个协作工作的网站,我顺便教了一个同行的游客如何使用ruby。然后,到了夜里,我跟Soho里的一些冲浪爱好者狂欢到凌晨。

香港景色

从泰国到柬埔寨到越南是我这次旅行中做喜欢的部分,如果你从没有到过亚洲,你绝对应该去一次。这些国家非常的漂亮,气候非常的好,食物美味可口,人们非常友善。吴哥窟是世上最神奇的地方之一,每个人都应该去看看。是Trey?Ratcliff的照片把我吸引到了那里,我的很多其它旅游目的地也是受了他的影响。那个家伙是很多旅游地的第一宣传者。

吴哥窟景色

在一些无名的小博客中,我听有人说过一个很远的美丽的小岛,在柬埔寨的海边。说小岛的Sihanoukville这个地方有个酒吧,说只能坐小渔船到那里。我,还有几个非常好的朋友,乘坐晚上的大巴,开始寻找这个传说中的酒吧。搜索差不多进行了一整天,每一个问过的酒吧都把我们指向另外一个酒吧。最终,我们问了出来,并在第二天早晨做短程巴士去了那个地方。

柬埔寨风景

上面的照片上是海岸边一个10美元一晚的小木屋。从当地居民区离开后,我们的队伍像小岛上唯一的人,我们随性自由的奔跑。白天我们懒懒的躺在海滩上,吃着岛上厨师准备的鲜美可口的水果沙拉,在夜晚,我们在到处是浮游生物的海里游泳。

柬埔寨风景2

下一站是越南,我们沿着湄公河支流来到一个边界上的小镇,我们是这里唯一的西方人,交流成了最大的问题。幸运的是,我们发现一个也许是镇上唯一会说英语的人,他骑车当我们的向导。当我的信用卡被那里的一个自动取款机吞掉了后,他提供了我很大的帮助!

越南风景

我们的队伍分成了几路,在我到达越南时,我的书正在按计划完成,进行的非常顺利。此时,我在西贡多待了几周,让我在书的好几章上有了重大的进展,正好是中国旧历新年,气氛非常的壮观热闹。

接着是日本,澳大利亚,新西兰和夏威夷。我很难把我所有的感受都在这篇文章里写出来,但说这是此生难忘的一段历程是不为过的。把如此多的美景都放到一个国家里,太让人赞叹了,我说的正是新西兰。我最喜爱的一段记忆是沿着Wanaka的一个湖边在阳光下跑步,还有就是背着食物和生活用品,徒步数天穿越Routeburn的大山。在这个国家的旅途中,我结识了好几个值得一生相伴的好友。这是一个真正的天堂。

就在我环绕新西兰的南部岛屿时,我的书终于完成了,提交给了技术编辑校对。

新西兰风景

接下来是纽约和旧金山,这两个神奇的地方到处是天才的程序员,有些人我很幸运的认识。Techcrunch?Disrupt办的很精彩(我高度推荐hackathon)。

在从纽约到旧金山的中途停留期间,我在各种公司了进行了不少的求职面试,最终在Twitter公司找到了一份做前端开发的工作。要在那里和杰出的团队一起工作,我不能不高兴的颤抖,而去旧金山,同样也是我此生的一个梦想。

当签证的事办下来了后,我去了中、南美洲旅行,同时开发了我的一个小工程:一个JavaScript?MVC框架库,叫做Spine。我到了哥斯达黎加,巴拿马,秘鲁,Bolvia,和阿根廷。?秘鲁是我的最爱,尽管那里的海拔给我带来了不少麻烦,我大部分的时间都在探险。下面的图片是哥斯达黎加传说中神奇猎鹰,是在我爬下世界最深的峡谷时拍到的。

Colca Canyon

当我在哥斯达黎加时,微博上有个叫Roberto的家伙给我发了条信息,说他读了我的书,问我是否有兴趣一起冲浪。我欣然同意,坐上去圣何塞的汽车,在几天后和他会了面。那天我们一起在他海边的公寓里开发Spine和Ruby项目,使用移动硬盘,用汽车电源给笔记本充电。当电量不足后,让太阳能板补充能量,我们去冲浪。

哥斯达黎加风景

我推荐大家去写一本书,特别是边旅游边写书。可以想象,如果我不去旧金山去看一看,我可能还在旅途中,做顾问,去创业。当作家并不能让你直接的挣到很多钱,但它绝对能提升你的身份地位,给你带来很多潜在的机会。事实上,写作过程让我真正享受的是,我可以认真深入的研究一个题目。

泰国风景

这一年是我这辈子目前为止最好的一年,而我感觉今后的一年会更好。当我如今定居下来后,我并没有感觉旅行对我的吸引力减少了;我始终把签证放到一个口袋里,而另一个口袋里装着钱包,当召唤降临,随时准备离开。

可是,这篇文章并不是关于我的旅行,它是要发送一个信号:

对于程序员来说,有个得天独厚的条件,就是这种职业可以远程工作或边旅游边工作,这是其它职业办不到的。当然,也不都是这样,在我的旅途中,我没有碰到第二个跟我的做法相似的程序员。这种情况让人悲哀。我想向程序员们送出的信息是,不要再找借口了,行动起来,你可以做到。一个人只有一生,我可以向你保证,这样的生活才不枉世间走这一遭。

就像我,我感到极度的幸运,能这样的生活,去发现我的热情所在,去做每天我喜欢做的事情。你可以看出,大部分我现在的境遇并非偶然或侥幸,这是计划,追求,工作的结果。

一份汗水,一份收成。

这篇文章的目标不是做一些自我陶醉似的炫耀和大话,而是向大家演示如何立下目标,鼓励大家去做相似的事情。想清楚你现在的处境,这一年内你想得到什么,制定出一系列具体的能让你到达这些目标的步骤。追随你的梦想。

[英文原文:Traveling,?Writing?and?Programming?]

转载自外刊IT评论。

旅行计划

去年毕业了,一直想来场旅行或者骑行,但是一直都是与想法有冲动一直没有去执行。今天在微博上看有人想去西藏,所以就想有一天能带她去西藏走走该多好呀。哪怕最后我们没有成功,来一场一个人的旅行也不错啊,但是仔细想想要去西藏还不是说能去就去的,还得提前做做准备,毕竟去的是高原地区,如果准备不足还是真有可能把命丢那里了。So,写篇日志坐下记录,最重要的是时刻提醒自己还有这么一个梦想。

准备工作:

1.资金(我觉得去一次的话没人至少要准备5K吧,虽然在来来会上这都赶上去东南亚国家旅游一个星期了)

2.锻炼身体,这个要求和自己的年度计划减肥10斤计划不谋而合了,哈哈,高原地区要有耐力嘛

3.一个旅行计划,最好还有个向导最好了。以前有个高中同学zxd在西藏边工作边旅行过,可以问问她,让她给一些建议。

4.时间安排,毕竟在工作,要结合工作时间来安排个旅行时间。

5.补充旅行方面的常识,以应付一些突发情况。

对于旅行的想法一直以来都来,一个是为了放松自己,让自己能够开阔眼界,古人说“读万卷书不如行万里路”,其实说的就是这个道理嘛,走着走着要多事情就想通了,自己的人生目标就明确了,想知道自己真正想要的是什么是自己一直想弄明白的。还有一个原因是来场自己的旅行就像自己独立地完成一件事一样,会给自己带来不一样的感受,会锻炼自己的独立能力还有想象力和创造力。

除了西藏,我还想要去的2个地方分别是美国和吴哥窟。去美国是高中就有的一个小想法,只是但是觉得不现实罢了,就没多想。想去吴哥窟主要是想去看看世界4大文明古迹,去净化自己的心灵,就像乔布斯当初去印度游学一样,艰苦忙碌而不失充实的生活会给自己带来很多顿悟。

除此之外今天在穷游折扣上看到了招聘的消息,发现这个专注于旅游的互联网公司还不错,工作环境也很开放,想想每天的工作和自己想做的事相关该是一件多么令人兴奋的事啊。不过遗憾的事,看了穷游的招聘要求和自己学的现在做的不太对口,有时间关注关注那里的岗位然后向那里靠近。嘻嘻。。。写完这些心理忽然开朗放松许多,有兴趣,有方向,有目标,一切感觉就好多了。这样在工作在做事的时候就知道自己现在为什么要这样做了,不管结果如何我们都会因为涉事而成长!

纯js脚本1k大小的3D玫瑰 程序员专用(收藏)

这是用代码做出的玫瑰花

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<!doctype html>
<html>
<head>
<title>Love</title>
<meta charset="utf-8" />
<!--[if IE]>?????????????????????????????????????????????????????????????????
<![endif]-->
</head>
<body>
<canvas id="c"></canvas>
<script>
????var b = document.body;
????var c = document.getElementsByTagName('canvas')[0];
????var a = c.getContext('2d');
????document.body.clientWidth;?
</script>
<script>
????// start of submission //
????with (m = Math) C = cos, S = sin, P = pow, R = random; c.width = c.height = f = 500; h = -250; function p(a, b, c) { if (c > 60) return [S(a * 7) * (13 + 5 / (.2 + P(b * 4, 4))) - S(b) * 50, b * f + 50, 625 + C(a * 7) * (13 + 5 / (.2 + P(b * 4, 4))) + b * 400, a * 1 - b / 2, a]; A = a * 2 - 1; B = b * 2 - 1; if (A * A + B * B < 1) { if (c > 37) { n = (j = c & 1) ? 6 : 4; o = .5 / (a + .01) + C(b * 125) * 3 - a * 300; w = b * h; return [o * C(n) + w * S(n) + j * 610 - 390, o * S(n) - w * C(n) + 550 - j * 350, 1180 + C(B + A) * 99 - j * 300, .4 - a * .1 + P(1 - B * B, -h * 6) * .15 - a * b * .4 + C(a + b) / 5 + P(C((o * (a + 1) + (B > 0 ? w : -w)) / 25), 30) * .1 * (1 - B * B), o / 1e3 + .7 - o * w * 3e-6] } if (c > 32) { c = c * 1.16 - .15; o = a * 45 - 20; w = b * b * h; z = o * S(c) + w * C(c) + 620; return [o * C(c) - w * S(c), 28 + C(B * .5) * 99 - b * b * b * 60 - z / 2 - h, z, (b * b * .3 + P((1 - (A * A)), 7) * .15 + .3) * b, b * .7] } o = A * (2 - b) * (80 - c * 2); w = 99 - C(A) * 120 - C(b) * (-h - c * 4.9) + C(P(1 - b, 7)) * 50 + c * 2; z = o * S(c) + w * C(c) + 700; return [o * C(c) - w * S(c), B * 99 - C(P(b, 7)) * 50 - c / 3 - z / 1.35 + 450, z, (1 - b / 1.2) * .9 + a * .1, P((1 - b), 20) / 4 + .05] } } setInterval('for(i=0;i<1e4;i++)if(s=p(R(),R(),i%46/.74)){z=s[2];x=~~(s[0]*f/z-h);y=~~(s[1]*f/z-h);if(!m[q=y*f+x]|m[q]>z)m[q]=z,a.fillStyle="rgb("+~(s[3]*h)+","+~(s[4]*h)+","+~(s[3]*s[3]*-80)+")",a.fillRect(x,y,1,1)}', 0)
????// end of submission //
</script>
</body>
</html>

 

RMI 数据源方式

相关资料:ObjectWeb??http://rmijdbc.ow2.org/
下载驱动:RmiJdbc.jar
?
Make?your?CLASSPATH?variable?point?on?the?RmiJdbc.jar?package:?it?is?located?in?the?dist/lib?subdirectory?of?the?RmiJdbc?distribution
  • Unix?example?(bash?style):
    export?CLASSPATH=$CLASSPATH:/usr/local/RmiJdbc/dist/lib/RmiJdbc.jar
  • Windows?example:
    set?CLASSPATH=%CLASSPATH%;C:\RmiJdbc\dist\lib\RmiJdbc.jar

Start?the?RmiJdbc?Server?component:

java?org.objectweb.rmijdbc.RJJdbcServer?[-noreg]?[-port?regportnum]?[-lp?portnum]?[-sm]?[-ssl]?[driverList]

Options:

  • -noreg:?means?you?launch?the?RmiJdbc?server?with?an?external?rmiregistry.
  • -port?regportnum:?specify?the?rmiregistry?port?(optional,?useful?if?you?launch?rmiregistry?on?a?port?of?your?own).
  • -lp?portnum:?specify?the?listener?port?for?remote?objects?(optional,?useful?if?need?to?use?a?single?port?for?remote?objects?-?otherwise,?dynamically?allocated?ports?are?used).
  • -sm:?use?the?standard?RMI?SecurityManager?(otherwise,?a?relaxed?SecurityManager?is?used,?equivalent?to?the?RMI?SecurityManager?with?AllPermissions?set).
  • -ssl:?use?in?SSL?mode?(see?documentation?for?details).
  • driverList:?list?of?JDBC?Driver?classes?available?on?your?server?(ex.?org.enhydra.instantdb.jdbc.idbDriver).?You?can?also?declare?your?driver?list?in?the?jdbc.drivers?system?property?(java?-Djdbc.drivers=driverList?RmiJdbc.RJJdbcServer).

Then,?a?remote?JDBC?client?can?access?your?local?database!

client?code?for?example:

import?java.sql.*;

import?java.rmi.*;
import?RmiJdbc.*;
import?java.net.InetAddress;
/**?*?This?is?a?sample?program?for?RmiJdbc?client/server?jdbc?Driver?*?RmiJdbc?relies?on?Java?RMI?for?jdbc?objects?distribution?*/
public?class?TestClient?{?
?public?static?void?main(String[]?args)?{????
??????try?{??????
???????????//?Register?RmiJdbc?Driver?in?jdbc?DriverManager??????
??????????//?On?some?platforms?with?some?java?VMs,?newInstance()?is?necessary...?????
???????????Class.forName("org.objectweb.rmijdbc.Driver").newInstance();??????
???????????//?Test?with?InstantDB?java?database?engine??????
???????????//?See?http://www.lutris.com/products/instantDB/index.html??????
????????????//?for?info?&?download?????
????????????String?url?=?"jdbc:idb:sample.prp";??????//?RMI?host?will?point?to?local?host?????
??????????String?rmiHost?=?new?String(???????"//"?+?InetAddress.getLocalHost().getHostName());??????
???????????//?RmiJdbc?URL?is?of?the?form:?????
??????????//?jdbc:rmi://<rmiHostName[:port]>/<jdbc-url>??????
??????????java.sql.Connection?c?=?DriverManager.getConnection("jdbc:rmi:"???????+?rmiHost?+?"/"?+?url);?????????????java.sql.Statement?st?=?c.createStatement();?????
????java.sql.ResultSet?rs?=?st.executeQuery("SELECT?*?FROM?import1");????
???????java.sql.ResultSetMetaData?md?=?rs.getMetaData();????
???????while(rs.next())?{???????
??????????????????System.out.print("\nTUPLE:?|?");??????
??????????????????for(int?i=1;?i<=?md.getColumnCount();?i++)?{????????
?????????????????????????????????System.out.print(rs.getString(i)?+?"?|?");????????}??????
??????????????????????}??????rs.close();??
????????????????????}?catch(Exception?e)?{??????e.printStackTrace();????}??}};
?
和Spring集成的方式(首先也需要Start?the?RmiJdbc?Server?component):
1.加入相应的Jar包
2.在applicationContext.xml中加入bean
?????<bean?id="wldtDataSource"class="org.springframework.jdbc.datasource.DriverManagerDataSource">
???????????????<property?name="driverClassName">
?????????????????????<value>org.objectweb.rmijdbc.Driver</value>
????????????</property>
???????????<property?name="url">
???????????????????<value>jdbc:rmi://172.20.52.26/jdbc:odbc:SiteWeaver</value><!--java默认1099端口-->
??????????</property></bean><bean?id="wldtjdbcDAO"?class="com.thunisoft.summer.dao.jdbc.JdbcDAO">
?????????<property?name="dataSource">
????????????????????<ref?bean="wldtDataSource"?/>
????????</property>
?</bean>
3.在DAO层注入数据源
????????private?JdbcTemplate?getWldtJdbcTemplate()????{??????
????????????????return?((JdbcDAO)?AppContext.getInstance().getAppContext().getBean(?"wldtjdbcDAO")).getJdbcTemplate();????}
其中JdbcDAO继承了?JdbcDAO?extends?JdbcDaoSupport?在其中注入了相应的数据源,方便调用其提供的模版方法template
?

4.在RMI的server端还需要设置ODBC数据源

如图:

30天学习30种新技术系列

原文地址:http://segmentfault.com/a/1190000000349384

编者注:我们发现了比较有趣的系列文章《30天学习30种新技术》,准备翻译,一天一篇更新,年终礼包。以下是译文,英文标题表示还未翻译,附原文链接;中文标题表示已翻译,附译文链接。

更新:全系列已经全部翻译完了~

让你30天学习30种新技术,你会觉得这是挑战吗?

img-1

我已经接受了挑战,我会在一个月的时间内每天学习一门新技术,挑战开始于2013年10月29日。下面就是我将要学习的新技术的列表,我会把每天学到的内容写出来。在我每天正常的工作之后,我会花几个小时学习一门新技术,再用一小时将今天学到的写在博客上。这项活动的目的是熟悉许多在开发者社区所使用的新技术。

我会把重点放在JavaScript及其相关技术的学习上,当然也会去了解一下像Java这类我比较感兴趣的其他技术。我也可能会在一门技术上花费好几天的时间,但我每次会选择和这门技术相关的不同的主题来讲。只要是有意义的,我将尽量展示它如何与OpenShift工作,我希望这是一次充满乐趣并能学到很多东西的旅程。(你可以在twitter上follow?我

下边是学习列表:


原文?Learning?30?Technologies?in?30?Days:?A?Developer?Challenge
翻译?SegmentFault

 

JVM调优总结-Xms -Xmx -Xmn -Xss(转载)

  1. 堆大小设置
    JVM?中最大堆大小有三方面限制:相关操作系统的数据模型(32-bt还是64-bit)限制;系统的可用虚拟内存限制;系统的可用物理内存限制。32位系统下,一般限制在1.5G~2G;64为操作系统对内存无限制。我在Windows?Server?2003?系统,3.5G物理内存,JDK5.0下测试,最大可设置为1478m。
    典型设置:

java?-Xmx3550m?-Xms3550m?-Xmn2g?-Xss128k
Xmx3550m:设置JVM最大可用内存为3550M。
-Xms3550m:设置JVM促使内存为3550m。此值可以设置与-Xmx相同,以避免每次垃圾回收完成后JVM重新分配内存。
-Xmn2g:设置年轻代大小为2G。整个JVM内存大小=年轻代大小?+?年老代大小?+?持久代大小。持久代一般固定大小为64m,所以增大年轻代后,将会减小年老代大小。此值对系统性能影响较大,Sun官方推荐配置为整个堆的3/8。
-Xss128k:设置每个线程的堆栈大小。JDK5.0以后每个线程堆栈大小为1M,以前每个线程堆栈大小为256K。更具应用的线程所需内存大小进行调整。在相同物理内存下,减小这个值能生成更多的线程。但是操作系统对一个进程内的线程数还是有限制的,不能无限生成,经验值在3000~5000左右。

java?-Xmx3550m?-Xms3550m?-Xss128k?-XX:NewRatio=4?-XX:SurvivorRatio=4?-XX:MaxPermSize=16m?-XX:MaxTenuringThreshold=0
-XX:NewRatio=4:设置年轻代(包括Eden和两个Survivor区)与年老代的比值(除去持久代)。设置为4,则年轻代与年老代所占比值为1:4,年轻代占整个堆栈的1/5
-XX:SurvivorRatio=4:设置年轻代中Eden区与Survivor区的大小比值。设置为4,则两个Survivor区与一个Eden区的比值为2:4,一个Survivor区占整个年轻代的1/6
-XX:MaxPermSize=16m:设置持久代大小为16m。
-XX:MaxTenuringThreshold=0:设置垃圾最大年龄。如果设置为0的话,则年轻代对象不经过Survivor区,直接进入年老代。对于年老代比较多的应用,可以提高效率。如果将此值设置为一个较大值,则年轻代对象会在Survivor区进行多次复制,这样可以增加对象再年轻代的存活时间,增加在年轻代即被回收的概论。

  1. 回收器选择
    JVM给了三种选择:串行收集器、并行收集器、并发收集器,但是串行收集器只适用于小数据量的情况,所以这里的选择主要针对并行收集器和并发收集器。默认情况下,JDK5.0以前都是使用串行收集器,如果想使用其他收集器需要在启动时加入相应参数。JDK5.0以后,JVM会根据当前系统配置进行判断。

吞吐量优先的并行收集器
如上文所述,并行收集器主要以到达一定的吞吐量为目标,适用于科学技术和后台处理等。
典型配置:?java?-Xmx3800m?-Xms3800m?-Xmn2g?-Xss128k?-XX:+UseParallelGC?-XX:ParallelGCThreads=20
-XX:+UseParallelGC:选择垃圾收集器为并行收集器。此配置仅对年轻代有效。即上述配置下,年轻代使用并发收集,而年老代仍旧使用串行收集。
-XX:ParallelGCThreads=20:配置并行收集器的线程数,即:同时多少个线程一起进行垃圾回收。此值最好配置与处理器数目相等。
java?-Xmx3550m?-Xms3550m?-Xmn2g?-Xss128k?-XX:+UseParallelGC?-XX:ParallelGCThreads=20?-XX:+UseParallelOldGC
-XX:+UseParallelOldGC:配置年老代垃圾收集方式为并行收集。JDK6.0支持对年老代并行收集。
java?-Xmx3550m?-Xms3550m?-Xmn2g?-Xss128k?-XX:+UseParallelGC??-XX:MaxGCPauseMillis=100
-XX:MaxGCPauseMillis=100:设置每次年轻代垃圾回收的最长时间,如果无法满足此时间,JVM会自动调整年轻代大小,以满足此值。
java?-Xmx3550m?-Xms3550m?-Xmn2g?-Xss128k?-XX:+UseParallelGC??-XX:MaxGCPauseMillis=100?-XX:+UseAdaptiveSizePolicy
-XX:+UseAdaptiveSizePolicy
:设置此选项后,并行收集器会自动选择年轻代区大小和相应的Survivor区比例,以达到目标系统规定的最低相应时间或者收集频率等,此值建议使用并行收集器时,一直打开。

响应时间优先的并发收集器
如上文所述,并发收集器主要是保证系统的响应时间,减少垃圾收集时的停顿时间。适用于应用服务器、电信领域等。
典型配置:?java?-Xmx3550m?-Xms3550m?-Xmn2g?-Xss128k?-XX:ParallelGCThreads=20?-XX:+UseConcMarkSweepGC?-XX:+UseParNewGC
-XX:+UseConcMarkSweepGC:设置年老代为并发收集。测试中配置这个以后,-XX:NewRatio=4的配置失效了,原因不明。所以,此时年轻代大小最好用-Xmn设置。
-XX:+UseParNewGC:设置年轻代为并行收集。可与CMS收集同时使用。JDK5.0以上,JVM会根据系统配置自行设置,所以无需再设置此值。
java?-Xmx3550m?-Xms3550m?-Xmn2g?-Xss128k?-XX:+UseConcMarkSweepGC?-XX:CMSFullGCsBeforeCompaction=5?-XX:+UseCMSCompactAtFullCollection
-XX:CMSFullGCsBeforeCompaction:由于并发收集器不对内存空间进行压缩、整理,所以运行一段时间以后会产生“碎片”,使得运行效率降低。此值设置运行多少次GC以后对内存空间进行压缩、整理。
-XX:+UseCMSCompactAtFullCollection:打开对年老代的压缩。可能会影响性能,但是可以消除碎片

  1. 辅助信息
    JVM提供了大量命令行参数,打印信息,供调试使用。主要有以下一些:

-XX:+PrintGC
输出形式:[GC?118250K->113543K(130112K),?0.0094143?secs]

????????????????[Full?GC?121376K->10414K(130112K),?0.0650971?secs]

-XX:+PrintGCDetails
输出形式:[GC?[DefNew:?8614K->781K(9088K),?0.0123035?secs]?118250K->113543K(130112K),?0.0124633?secs]

????????????????[GC?[DefNew:?8614K->8614K(9088K),?0.0000665?secs][Tenured:?112761K->10414K(121024K),?0.0433488?secs]?121376K->10414K(130112K),?0.0436268?secs]

-XX:+PrintGCTimeStamps?-XX:+PrintGC:PrintGCTimeStamps可与上面两个混合使用
输出形式:11.851:?[GC?98328K->93620K(130112K),?0.0082960?secs]

-XX:+PrintGCApplicationConcurrentTime:打印每次垃圾回收前,程序未中断的执行时间。可与上面混合使用
输出形式:Application?time:?0.5291524?seconds

-XX:+PrintGCApplicationStoppedTime:打印垃圾回收期间程序暂停的时间。可与上面混合使用
输出形式:Total?time?for?which?application?threads?were?stopped:?0.0468229?seconds

-XX:PrintHeapAtGC:打印GC前后的详细堆栈信息
输出形式:
34.702:?[GC?{Heap?before?gc?invocations=7:
def?new?generation???total?55296K,?used?52568K?[0x1ebd0000,?0x227d0000,?0x227d0000)
eden?space?49152K,??99%?used?[0x1ebd0000,?0x21bce430,?0x21bd0000)
from?space?6144K,??55%?used?[0x221d0000,?0x22527e10,?0x227d0000)
to???space?6144K,???0%?used?[0x21bd0000,?0x21bd0000,?0x221d0000)
tenured?generation???total?69632K,?used?2696K?[0x227d0000,?0x26bd0000,?0x26bd0000)
the?space?69632K,???3%?used?[0x227d0000,?0x22a720f8,?0x22a72200,?0x26bd0000)
compacting?perm?gen??total?8192K,?used?2898K?[0x26bd0000,?0x273d0000,?0x2abd0000)
the?space?8192K,??35%?used?[0x26bd0000,?0x26ea4ba8,?0x26ea4c00,?0x273d0000)
ro?space?8192K,??66%?used?[0x2abd0000,?0x2b12bcc0,?0x2b12be00,?0x2b3d0000)
rw?space?12288K,??46%?used?[0x2b3d0000,?0x2b972060,?0x2b972200,?0x2bfd0000)
34.735:?[DefNew:?52568K->3433K(55296K),?0.0072126?secs]?55264K->6615K(124928K)Heap?after?gc?invocations=8:
?def?new?generation???total?55296K,?used?3433K?[0x1ebd0000,?0x227d0000,?0x227d0000)
eden?space?49152K,???0%?used?[0x1ebd0000,?0x1ebd0000,?0x21bd0000)
from?space?6144K,??55%?used?[0x21bd0000,?0x21f2a5e8,?0x221d0000)
to???space?6144K,???0%?used?[0x221d0000,?0x221d0000,?0x227d0000)
tenured?generation???total?69632K,?used?3182K?[0x227d0000,?0x26bd0000,?0x26bd0000)
the?space?69632K,???4%?used?[0x227d0000,?0x22aeb958,?0x22aeba00,?0x26bd0000)
compacting?perm?gen??total?8192K,?used?2898K?[0x26bd0000,?0x273d0000,?0x2abd0000)
the?space?8192K,??35%?used?[0x26bd0000,?0x26ea4ba8,?0x26ea4c00,?0x273d0000)
ro?space?8192K,??66%?used?[0x2abd0000,?0x2b12bcc0,?0x2b12be00,?0x2b3d0000)
rw?space?12288K,??46%?used?[0x2b3d0000,?0x2b972060,?0x2b972200,?0x2bfd0000)
}
,?0.0757599?secs]

  1. -Xloggc:filename:与上面几个配合使用,把相关日志信息记录到文件以便分析。
  2. 常见配置汇总
  3. 堆设置
  4. -Xms:初始堆大小
  5. -Xmx:最大堆大小
  6. -XX:NewSize=n:设置年轻代大小
  7. -XX:NewRatio=n:设置年轻代和年老代的比值。如:为3,表示年轻代与年老代比值为1:3,年轻代占整个年轻代年老代和的1/4
  8. -XX:SurvivorRatio=n:年轻代中Eden区与两个Survivor区的比值。注意Survivor区有两个。如:3,表示Eden:Survivor=3:2,一个Survivor区占整个年轻代的1/5
  9. -XX:MaxPermSize=n:设置持久代大小
  10. 收集器设置
  11. -XX:+UseSerialGC:设置串行收集器
  12. -XX:+UseParallelGC:设置并行收集器
  13. -XX:+UseParalledlOldGC:设置并行年老代收集器
  14. -XX:+UseConcMarkSweepGC:设置并发收集器
  15. 垃圾回收统计信息
  16. -XX:+PrintGC
  17. -XX:+PrintGCDetails
  18. -XX:+PrintGCTimeStamps
  19. -Xloggc:filename
  20. 并行收集器设置
  21. -XX:ParallelGCThreads=n:设置并行收集器收集时使用的CPU数。并行收集线程数。
  22. -XX:MaxGCPauseMillis=n:设置并行收集最大暂停时间
  23. -XX:GCTimeRatio=n:设置垃圾回收时间占程序运行时间的百分比。公式为1/(1+n)
  24. 并发收集器设置
  25. -XX:+CMSIncrementalMode:设置为增量模式。适用于单CPU情况。
  26. -XX:ParallelGCThreads=n:设置并发收集器年轻代收集方式为并行收集时,使用的CPU数。并行收集线程数。

四、调优总结

  1. 年轻代大小选择
  2. 响应时间优先的应用尽可能设大,直到接近系统的最低响应时间限制(根据实际情况选择)。在此种情况下,年轻代收集发生的频率也是最小的。同时,减少到达年老代的对象。
  3. 吞吐量优先的应用:尽可能的设置大,可能到达Gbit的程度。因为对响应时间没有要求,垃圾收集可以并行进行,一般适合8CPU以上的应用。
  4. 年老代大小选择

响应时间优先的应用:年老代使用并发收集器,所以其大小需要小心设置,一般要考虑并发会话率会话持续时间等一些参数。如果堆设置小了,可以会造成内存碎片、高回收频率以及应用暂停而使用传统的标记清除方式;如果堆大了,则需要较长的收集时间。最优化的方案,一般需要参考以下数据获得:

    • 并发垃圾收集信息
    • 持久代并发收集次数
    • 传统GC信息
    • 花在年轻代和年老代回收上的时间比例
    • 减少年轻代和年老代花费的时间,一般会提高应用的效率

 

    1. 吞吐量优先的应用:一般吞吐量优先的应用都有一个很大的年轻代和一个较小的年老代。原因是,这样可以尽可能回收掉大部分短期对象,减少中期的对象,而年老代尽存放长期存活对象。
    2. 较小堆引起的碎片问题
      因为年老代的并发收集器使用标记、清除算法,所以不会对堆进行压缩。当收集器回收时,他会把相邻的空间进行合并,这样可以分配给较大的对象。但是,当堆空间较小时,运行一段时间以后,就会出现“碎片”,如果并发收集器找不到足够的空间,那么并发收集器将会停止,然后使用传统的标记、清除方式进行回收。如果出现“碎片”,可能需要进行如下配置:
    3. -XX:+UseCMSCompactAtFullCollection:使用并发收集器时,开启对年老代的压缩。
    4. -XX:CMSFullGCsBeforeCompaction=0:上面配置开启的情况下,这里设置多少次Full?GC后,对年老代进行压缩

 

JAVA虚拟机内存区域(转载整理)

JVM的体系结构,如下图:

其中,Runtime?DataArea(运行时数据区)是整个JVM的重点,平时,由于我们编写java程序很少关心内存的释放问题,这个都是JVM来自动管理的,不过,也正是因为Java程序员把内存控制的权力交给了JVM,一旦出现泄漏和溢出,如果不了解JVM是怎样使用内存的,那排查错误将会是一件非常困难的事情。这里就大致的介绍一下JVM的这一区域。

JVM中,所有的数据和程序都存放在运行时数据区,如上图,这个区域又包括几个子区域,它们各自有各自的用途和生命周期,?MethodArea和Heap是基于JVM实例的,即JVM的每个实例都有一个它自己的方法域和一个堆;PC?Register和Stack是基于线程的,即每个线程创建的时候,都会拥有自己的程序计数器和栈;Native?Method?Stack是为虚拟机用到的Native方法服务。下面分别介绍这几个区域:

1.Heap(堆)

一个JVM实例只存在一个堆内存,对于绝大多数应用来说,Java堆是虚拟机管理最大的一块内存。Java堆是被所有线程共享的,在虚拟机启动时创建。类加载器读取了类文件后,需要把类、方法、常变量放到堆内存中,以方便执行器执行,堆内存分为三部分:

a)Permanent?Space(永久存储区)

永久存储区是一个常驻内存区域,用于存放JDK自身所携带的Class,Interface的元数据,也就是说它存储的是运行环境必须的类信息,一般被装载进此区域的数据是不会被垃圾回收器回收掉的,关闭JVM才会释放此区域所占用的内存。

b)Young?Generation?Space(新生区)

新生区是类的诞生、成长、消亡的区域,一个类在这里产生,应用,最后被垃圾回收器收集,结束生命。新生区又分为两部分:伊甸区(Eden?space)和幸存者区(Survivor?pace),所有的类都是在伊甸区被new出来的。幸存区有两个:0区(Survivor?0space)和1区(Survivor?1space)。当伊甸园的空间用完时,程序又需要创建对象,JVM的垃圾回收器将对伊甸园区进行垃圾回收,将伊甸园区中的不再被其他对象所引用的对象进行销毁。然后将伊甸园中的剩余对象移动到幸存0区。若幸存0区也满了,再对该区进行垃圾回收,然后移动到1区。那如果1区也满了呢?再移动到养老区。

c)Tenure?Generation?Space(养老区)

养老区用于保存从新生区筛选出来的JAVA对象,一般池对象都在这个区域活跃。

三个区的示意图如下:

之所以将堆内存再进行分区,主要是基于这样一个事实:不同对象的生命周期是不一样的。在Java程序运行的过程中,会产生大量的对象,其中有些对象是与业务信息相关,比如Http请求中的Session对象、线程、Socket连接,这类对象跟业务直接挂钩,因此生命周期比较长。但是还有一些对象,主要是程序运行过程中生成的临时变量,这些对象生命周期会比较短,比如:String对象,由于其不变类的特性,系统会产生大量的这些对象,有些对象甚至只用一次即可回收。试想,在不进行对象存活时间区分的情况下,每次垃圾回收都是对整个堆空间进行回收,花费时间相对会长,同时,因为每次回收都需要遍历所有存活对象,但实际上,对于生命周期长的对象而言,这种遍历是没有效果的,因为可能进行了很多次遍历,但是他们依旧存在。因此,对堆进行分区管理是采用了分治的思想,把不同生命周期的对象放在不同区域,不同区域采用最适合它的垃圾回收方式进行回收。分区之后可以提高JVM垃圾收集的效率,进而优化内存管理。

无论对Java堆如何划分,目的都是为了更好的回收内存,或者更快的分配内存。如果在堆中无法分配内存,并且堆也无法再扩展时,将会抛出OutOfMemoryError异常。

2.Method?Area(方法域)

方法域实际上就是堆中的永久存储区(Permanent?Space),它还有个别名叫做Non-Heap(非堆),所以也可以将方法域看作堆的一个逻辑部分。方法域中存放了每个Class的结构信息,包括常量池、字段描述、方法描述等等。这个区域除了和Java堆一样不需要连续的内存,也可以选择固定大小或者可扩展外,甚至可以选择不实现垃圾收集。相对来说,垃圾收集行为在这个区域是相对比较少发生的,但并不是某些描述那样永久存储区不会发生GC(至少对当前主流的商业JVM实现来说是如此),这里的GC主要是对常量池的回收和对类的卸载,虽然回收的“成绩”一般也比较差强人意,尤其是类卸载,条件相当苛刻。对类的卸载需要满足下面3个条件:
1)该类所有的实例都已经被GC,也就是JVM中不存在该Class的任何实例;
2)加载该类的ClassLoader已经被GC;
3)该类对应的java.lang.Class?对象没有在任何地方被引用,如不能在任何地方通过反射访问该类的方法。

3.Stack(栈)

栈的生命周期也是与线程相同。栈描述的是Java方法调用的内存模型:每个方法被执行的时候,都会同时创建一个栈帧(Frame)用于存储本地变量表、操作栈、动态链接、方法出入口等信息。每一个方法的调用至完成,就意味着一个栈帧在栈中的入栈至出栈的过程。栈帧是一个内存区块,是一个数据集,是一个有关方法(Method)和运行期数据的数据集,当一个方法A被调用时就产生了一个栈帧F1,并被压入到栈中,A方法又调用了B方法,于是产生栈帧F2也被压入栈,执行完毕后,先弹出F2栈帧,再弹出F1栈帧,遵循“后进先出”原则。栈帧中主要保存3类数据:本地变量(LocalVariables),包括输入参数和输出参数以及方法内的变量;栈操作(Operand?Stack),记录出栈、入栈的操作;栈帧数据(Frame?Data),包括类文件、方法等等。

栈中有两种异常状况:如果线程请求的栈深度大于虚拟机所允许的深度,将抛出StackOverflowError异常;如果栈可以动态扩展,当扩展时无法申请到足够内存则抛出OutOfMemoryError异常。

4.PC?Register(程序计数器)

每一个Java线程都有一个程序计数器来用于保存程序执行到当前方法的哪一个指令。对于非Native方法,这个区域记录的是正在执行的VM原语的地址,该地址指向方法域中的方法字节码,由执行引擎读取下一条指令。如果正在执行的是Natvie方法,这个区域则为空。

5.Native?Method?Stack(本地方法栈)

本地方法栈与VM栈所发挥作用是类似的,只不过VM栈为虚拟机运行VM原语服务,而本地方法栈是为虚拟机使用到的Native方法服务。它的实现的语言、方式与结构并没有强制规定,甚至有的虚拟机(譬如Sun?Hotspot虚拟机)直接就把本地方法栈和VM栈合二为一。和VM栈一样,这个区域也会抛出StackOverflowError和OutOfMemoryError异常。

这里对运行时数据区的几个逻辑组成部分做了个大致的介绍,其中,同样是存储数据的栈和堆有什么区别呢?这可能也是我们编码时容易忽略的地方。下一节来分析一下这个。

 

两种JNI方法注册方式

JNI方法注册方式有两种:

  • 通过javah产生函数头,该种方式产生的方法具有固定的格式。该方式使逆向分析人员比较容易获取java层native方法对应的本地方法。
  • 在JNI_OnLoad方法中手动注册jni方法,不易查找对应关系。

注意与RMI,WebService,CORBA(Common?Object?Request?Broker?Architecture,公共对象请求代理体系结构)的区别.

JNI的资料:

jni.pdf