a垃圾收集器中英文毕业论文.doc

How a garbage collector works of Java Language If you come from a programming language where allocating objects on the heap is expensive, you may naturally assume that Javas scheme of allocating everything (except primitives) on the heap is also expensive. However, it turns out that the garbage collector can have a significant impact on increasing the speed of object creation. This might sound a bit odd at firstthat storage release affects storage allocationbut its the way some JVMs work, and it means that allocating storage for heap objects in Java can be nearly as fast as creating storage on the stack in other languages.For example, you can think of the C+ heap as a yard where each stakes out its own piece of turf object. This real estate can become abandoned sometime later and must be reused. In some JVMs, the Java heap is quite different; its more like a conveyor belt that moves forward every time you allocate a new object. This means that object storage allocation is remarkably rapid. The “heap pointer” is simply moved forward into virgin territory, so its effectively the same as C+s stack allocation. (Of course, theres a little extra overhead for bookkeeping, but its nothing like searching for storage.) You might observe that the heap isnt in fact a conveyor belt, and if you treat it that way, youll start paging memorymoving it on and off disk, so that you can appear to have more memory than you actually do. Paging significantly impacts performance. Eventually, after you create enough objects, youll run out of memory. The trick is that the garbage collector steps in, and while it collects the garbage it compacts all the objects in the heap so that youve effectively moved the “heap pointer” closer to the beginning of the conveyor belt and farther away from a page fault. The garbage collector rearranges things and makes it possible for the high-speed, infinite-free-heap model to be used while allocating storage. To understand garbage collection in Java, its helpful learn how garbage-collection schemes work in other systems. A simple but slow garbage-collection technique is called reference counting. This means that each object contains a reference counter, and every time a reference is attached to that object, the reference count is increased. Every time a reference goes out of scope or is set to null, the reference count is decreased. Thus, managing reference counts is a small but constant overhead that happens throughout the lifetime of your program. The garbage collector moves through the entire list of objects, and when it finds one with a reference count of zero it releases that storage (however, reference counting schemes often release an object as soon as the count goes to zero). The one drawback is that if objects circularly refer to each other they can have nonzero reference counts while still being garbage. Locating such self-referential groups requires significant extra work for the garbage collector. Reference counting is commonly used to explain one kind of garbage collection, but it doesnt seem to be used in any JVM implementations. In faster schemes, garbage collection is not based on reference counting. Instead, it is based on the idea that any non-dead object must ultimately be traceable back to a reference that lives either on the stack or in static storage. The chain might go through several layers of objects. Thus, if you start in the stack and in the static storage area and walk through all the references, youll find all the live objects. For each reference that you find, you must trace into the object that it points to and then follow all the references in that object, tracing into the objects they point to, etc., until youve moved through the entire Web that originated with the reference on the stack or in static storage. Each object that you move through must still be alive. Note that there is no problem with detached self-referential groupsthese are simply not found, and are therefore automatically garbage. In the approach described here, the JVM uses an adaptive garbage-collection scheme, and what it does with the live objects that it locates depends on the variant currently being used. One of these variants is stop-and-copy. This means thatfor reasons that will become apparentthe program is first stopped (this is not a background collection scheme). Then, each live object is copied from one heap to another, leaving behind all the garbage. In addition, as the objects are copied into the new heap, they are packed end-to-end, thus compacting the new heap (and allowing new storage to simply be reeled off the end as previously described).Of course, when an object is moved from one place to another, all references that point at the object must be changed. The reference that goes from the heap or the static storage area to the object can be changed right away, but there can be other references pointing to this object Initialization & Cleanup that will be encountered later during the “walk.” These are fixed up as they are found (you could imagine a table that maps old addresses to new ones).There are two issues that make these so-called “copy collectors” inefficient. The first is the idea that you have two heaps and you slosh all the memory back and forth between these two separate heaps, maintaining twice as much memory as you actually need. Some JVMs deal with this by allocating the heap in chunks as needed and simply copying from one chunk to another.The second issue is the copying process itself. Once your program becomes stable, it might be generating little or no garbage. Despite that, a copy collector will still copy all the memory from one place to another, which is wasteful. To prevent this, some JVMs detect that no new garbage is being generated and switch to a different scheme (this is the “adaptive” part). This other scheme is called mark-and-sweep, and its what earlier versions of Suns JVM used all the time. For general use, mark-and-sweep is fairly slow, but when you know youre generating little or no garbage, its fast. Mark-and-sweep follows the same logic of starting from the stack and static storage, and tracing through all the references to find live objects. However, each time it finds a live object, that object is marked by setting a flag in it, but the object isnt collected yet. Only when the marking process is finished does the sweep occur. During the sweep, the dead objects are released. However, no copying happens, so if the collector chooses to compact a fragmented heap, it does so by shuffling objects around. “Stop-and-copy” refers to the idea that this type of garbage collection is not done in the background; Instead, the program is stopped while the garbage collection occurs. In the Sun literature youll find many references to garbage collection as a low-priority background process, but it turns out that the garbage collection was not implemented that way in earlier versions of the Sun JVM. Instead, the Sun garbage collector stopped the program when memory got low. Mark-and-sweep also requires that the program be stopped.As previously mentioned, in the JVM described here memory is allocated in big blocks. If you allocate a large object, it gets its own block. Strict stop-and-copy requires copying every live object from the source heap to a new heap before you can free the old one, which translates to lots of memory. With blocks, the garbage collection can typically copy objects to dead blocks as it collects. Each block has a generation count to keep track of whether its alive. In the normal case, only the blocks created since the last garbage collection are compacted; all other blocks get their generation count bumped if they have been referenced from somewhere. This handles the normal case of lots of short-lived temporary objects. Periodically, a full sweep is madelarge objects are still not copied (they just get their generation count bumped), and blocks containing small objects are copied and compacted.The JVM monitors the efficiency of garbage collection and if it becomes a waste of time because all objects are long-lived, then it switches to mark-and sweep. Similarly, the JVM keeps track of how successful mark-and-sweep is, and if the heap starts to become fragmented, it switches back to stop-and-copy. This is where the “adaptive” part comes in, so you end up with a mouthful: “Adaptive generational stop-and-copy mark-and sweep.”There are a number of additional speedups possible in a JVM. An especially important one involves the operation of the loader and what is called a just-in-time (JIT) compiler. A JIT compiler partially or fully converts a program into native machine code so that it doesnt need to be interpreted by the JVM and thus runs much faster. When a class must be loaded (typically, the first time you want to create an object of that class), the .class file is located, and the byte codes for that class are brought into memory. At this point, one approach is to simply JIT compile all the code, but this has two drawbacks: It takes a little more time, which, compounded throughout the life of the program, can add up; and it increases the size of the executable (byte codes are significantly more compact than expanded JIT code), and this might cause paging, which definitely slows down a program. An alternative approach is lazy evaluation, which means that the code is not JIT compiled until necessary. Thus, code that never gets executed might never be JIT compiled. The Java Hotspot technologies in recent JDKs take a similar approach by increasingly optimizing a piece of code each time it is executed, so the more the code is executed, the faster it gets.Java垃圾收集器的工作方式 如果你学下过一种因为在堆里分配对象所以开销过大的编程语言，很自然你可能会假定 Java 在堆里为每一样东西（除了 primitives）分配内存资源的机制开销也会很大。不过，事实上垃圾收集器能够深刻影响对象的加速创建。 一开始听起来有些奇怪存贮空间的释放会影响存贮空间的分配，但是这的确是一些 JVMs 的工作方式，并且这意味着 Java 为堆对象分配存贮空间几乎和别的语言里为栈分配存贮空间一样地快。举个例子，你可以认为 C+的堆就如同一个堆放的工场，在这个工场里，每一个对象都立有的地皮占有权不久会被废除无效，并且这块地皮必须重新加以利用。在Java 的 JVM 里，堆的工作方式完全不同；每次为一个新的对象分配存贮空间的时候，它就更像是一个不断向前移动的传送带。 这就意味着对象存贮空间的分配速度明显加快。 在这个过程中，“堆指针”简单地向还没被占用的空间领域移动，所以非常像 C+里栈的分配方式。（当然，记录工作会有一点额外的开销，但是完全不同于 C+里那种在堆放工场里为寻找没被利用的存贮空间而付出的开销。）你或许观察到实际上堆本身并不是一个传送带，如果你真的那样看待堆，你就会启用虚拟内存在硬盘里不断地装卸，结果是看上去你会拥有比实际情况还要多的内存空间。 最终，当你创建了足够多的对象后，你会耗尽内存。 Java 的诀窍就在于垃圾搜集器插手于其中，当垃圾收集器收集垃圾的时候，它会压缩所有堆里的对象以便你能够有效的将堆指针移动到相应的地方从而远离了页面错误。垃圾收集器重新安排了整个过程，这使得分配存贮空间的时候一种高速，无穷闲置的堆模式成为可能。要想理解 Java 的垃圾收集工作，先了解一下别的语言系统里垃圾收集所使用的方案是有帮助的。 一种简单的但却较慢的垃圾收集技术就是引用记数（reference counting）。这种技术意味着每个对象都含有一个引用计数器，每一次一个引用指向那个对象的时候，引用记数就增加1 每一次对象引用离开作用域或者被设置为 null 的时候，引用记数就减1。 因此，应付对象被引用的数量在你的程序的整个生命周期里是一笔较小但却一直持续的开销。垃圾收集器历遍整组对象，当它发现一个引用记数为零的对象时就会释放那个对象的存贮空间。（不过，只要记数为零，引用记数方案通常会立刻释放对象）。 这种方案的一个缺点是如果对象之间循环着互相引用，那么这些对象的引用记数可能为非零，而垃圾收集器依然把它们当作垃圾收集。 定位这种自我引用的对象组需要垃圾收集器付出大量额外的工作。引用记数通常被用来解释一类垃圾收集的工作原理，但是它似乎没被任何一种 JVM 所采纳。有一种执行更快的垃圾收集方案，这种方案中垃圾收集不是建立在引用记数的基础上。相反，它的思想是任何没死的对象最终一定会在栈和静态存贮器里找到相应存活的引用。这种链式的查找方式可能历遍几个层次的对象组。因此，如果从栈和静态存贮器里开始并历遍整个引用组，你会找到所有存活的对象。对于你找到的每个单引用，你必须找到它所指向的对象，然后发觉那个对象的所有引用，接着找到那些引用所指向的所有对象，依次类推，直到你历遍整个由栈和静态存贮器里的引用所形成的网。每个你找到的对象必须还存活着。注意，这里不存在分离的自我引用的对象组他们只是没被查找到，因此被自动当作垃圾。在上述提到的垃圾收集方案中，JVM 使用了一种自适应的垃圾收集方案，它对查找到的存活对象采取的措施依赖于它正在使用的方案变体。其中的一个变体就是 stop-and-copy。 它意味着基于一些明显的原因程序首先停止运行（这不是一种在后台实施的垃圾收集方案）。然后，每一个活着的对象从一个堆里被拷贝到另一个堆里，同时被拷贝的活对象和死的对象被当作垃圾遗弃。并且，当对象被拷贝到新的堆里后，他们在那里被一个挨一个塞紧，因此实现了压缩新堆的目的（而且如前所述，这种方式腾出了压缩后多余出来的新的空间）。当然，对象从一个地方移动到另一个地方的时候，所有指向对象的引用必须相应改变。 指向堆或者静态存贮器里某个被移动对象的引用可以立即得到改变，但是还存在其它后来“在走走”的时候才会碰到的指向该对象的引用。 这些引用一旦发现就会被修改。（你可以想象存在一张映射旧新地址的表）。有两个问题使这种所谓的“拷贝型收集器”缺乏效率。 第一个问题就是你使用了两个堆，为了维护两倍于你实际所需要的内存空间，你得在这两个堆之间来回搅动着整个内存空间。 一些 JVMs 通过依据实际所需来为堆分配大块内存，然后很简单地从一个块拷贝对象到另一个。第二个问题是拷贝过程本身。 一旦你地程序趋向于稳定的时候，它可能生成很少或者几乎不生成垃圾。 然而 stop-and-copy 方案不管这些，拷贝型垃圾收集器依旧把活对象占用的空间从一个地方拷贝到另一个地方，这就形成了浪费。 为了阻止这种情况的发生，一些 JVMs会探测没有新垃圾产生的时机，并且会转向实施另外一个完全不同的垃圾收集方案。 这种不同的方案被称为 mark-and-sweep，并且它是 Sun 的早期 JVM 版本一直使用的方案。 处理一般的垃圾收集工作，mark-and-sweep 表现得相当地慢，但是当你的程序生成很少或者不生成垃圾时，它又运行得很快。Mark-and-sweep 遵循着和 stop-and-copy 一样的逻辑：从栈和静态存贮器里出发，跟踪所有的引用从而找到存活的对象。 不过，每次它找到活对象的时候，那个对象被做以标记，而且对象还不会被收集起来。 只有在整个标记过程完成后，清扫（sweep）工作才真正开始。在清扫过程中，死对象被释放存贮空间。不过，Mark-and-sweep 方案的实施过程并没有拷贝压缩的步骤发生，所以如果垃圾收集器打算压缩已经成为碎片的堆，它会采用如同洗牌一样的方式来重新安排对象的散乱分布。stop-and-copy 的思想是垃圾收集不在后台完成，相反，程序需要停止运行的同时垃圾收集开始工作。在 Sun 的文献资料里，你会发现很多资料认为垃圾收集是一种低优先性的后台进程，但事实上垃圾收集在早期的 Sun JVM 版本里并不是这样执行地。相反，当内存闲置空间少的时候，Sun 的垃圾收集器会终止程序运行。 Mark-and-sweep 也需要程序被终止。正如前面提到的，在这里描述的 JVM 里，内存被分配成大的块。 如果你指定了一个大的对象，它将会得到它自己的内存块。 严格意义上的 stop-and-copy 在可以释放旧堆之前，需要从源堆里拷贝每一个活着的对象到新的堆里，这会耗费大量内存。 而有了块的概念，垃圾收集器在收集的时候就能够拷贝对象到死的块里。每一个块都有一个生成数用来跟踪它是否还活着。正常情况下，只有自上次垃圾收集后创建的块才被压缩；所有别的块，如果在什么地方被引用的话，相应的生成记数会增加。 这种方式解决了通常情况下许多短期生存的暂时对象。彻底的清扫工作会周期性进行。大的对象仍旧不拷贝（他们只是把自己的生成记数增加），而那些包含小对象的块会被拷贝和压缩。 JVM 会监视垃圾收集的效率，如果是因为所有的对象都稳定运行而使得收集工作比较浪费时间的话，垃圾收集会转向 mark-and-sweep 模式。同样地，JVM 也会跟踪 mark-and-sweep 的运行效果，如果堆开始变得零碎不堪，垃收集又会转回 stop-and-copy 模式。 这就是“自适应”概念的来源，所以你能总结出一句冗长拗口的话： “自适应地分阶段地 stop-and-copy mark-and-sweep。”JVM 里，可能会有一些附带的加速技术。 一项很重要的技术就涉及到那个加载程序的操作，它被称为 just-in-time（JIT）编译器。 JIT 编译器能部分或者全部把程序转换成机器能够识别的代码，所以程序就不需要 JVM 的解释了，结果是程序运行起来快很多。当必须加载类的时候（特别是你第一次想创建那个类的对象的时候），首先定位 .class 文件，然后相应的字节码被送入内存。 这个时候，一个可以利用的方式就是直接让 JIT 编译所有的代码，但是这样做有两个缺点： 这种方式的应用由于混杂在程序的整个生命周期里，所以能累加起来，从而导致程序执行起来会花费一些额外的时间；另外它也增加了可执行程序的尺寸（字节码要比已扩展的 JIT 代码压缩度高出很多），因此有可能导致虚拟内存的使用，结果明显地降低了程序的运行效率。一个替代方案就是 lazy evaluation，它的意思是直到代码需要的时候，才用 JIT 来编译。 因此，从来都不执行的代码可能永远都不被 JIT 编译。 在最近的 JDKV 里采用的 Java HotSpot 技术也使用了一种类似方案，一段代码每执行一次，该技术就优化一次代码，所以运行的次数越多，代码执行的速度就越快。以下内容与本文档无关！以下内容与本文档无关！。以下为赠送文档，祝你事业有成，财源广进，身体健康，家庭和睦！高效能人士的50个习惯l 在行动前设定目标有目标未必能够成功，但没有目标的肯定不能成功。著名的效率提升大师博思.崔西説：“成功就是目标的达成，其他都是这句话的注释。”现实中那些顶尖的成功人士不是成功了才设定目标，而是设定了目标才成功。一次做好一件事著名的效率提升大师博思.崔西有一个著名的论断：“一次做好一件事的人比同时涉猎多个领域的人要好得多。”富兰克林将自己一生的成就归功于对“在一定时期内不遗余力地做一件事”这一信条的实践。培养重点思维从重点问题突破，是高效能人士思考的一项重要习惯。如果一个人没有重点地思考，就等于无主要目标，做事的效率必然会十分低下。相反，如果他抓住了主要矛盾，解决问题就变得容易多了。发现问题关键在许多领导者看来，高效能人士应当具备的最重要的能力就是发现问题关键能力，因为这是通向问题解决的必经之路。正如微软总裁兼首席软件设计师比尔。盖茨所説：“通向最高管理层的最迅捷的途径，是主动承担别人都不愿意接手的工作，并在其中展示你出众的创造力和解决问题的能力。”把问题想透彻把问题想透彻，是一种很好的思维品质。只要把问题想透彻了，才能找到问题到底是什么，才能找到解决问题最有效的手段。不找借口美国成功学家格兰特纳说过这样的话：“如果你有为自己系鞋带的能力，你就有上天摘星星的机会！”一个人对待生活和工作是否负责是决定他能否成功的关键。一名高效能人士不会到处为自己找借口，开脱责任；相反，无伦出现什么情况，他都会自觉主动地将自己的任务执行到底。要事第一创设遍及全美的事务公司的亨瑞。杜哈提说，不论他出多小钱的薪水，都不可能找到一个具有两种能力的人。这两种能力是：第一，能思想；第二，能按事情的重要程度来做事。因此，在工作中，如果我们不能选择正确的事情去做，那么唯一正确的事情就是停止手头上的事情，直到发现正确的事情为止。运用20/80法则二八法则向人们揭示了这样一个真理，即投入与产出、努力与收获、原因和结果之间，普遍存在着不平衡关系。小部分的努力，可以获得大的收获；起关键作用的小部分，通常就能主宰整个组织的产出、盈亏和成败。合理利用零碎时间所谓零碎时间，是指不构成连续的时间或一个事务与另一事务衔接时的空余时间。这样的时间往往被人们毫不在乎地忽略过去，零碎时间虽短，但倘若一日、一月、一年地不断积累起来，其总和将是相当可观的。凡事在事业上有所成就的人，几乎都是能有效地利用零碎时间的人。习惯10、废除拖延对于一名高效能人士来説，拖延是最具破坏性的，它是一种最危险的恶习，它使人丧失进取心。一旦开始遇事推托，就很容易再次拖延，直到变成一种根深崹蒂固的习惯。习惯11、向竞争对手学习一位知名的企业家曾经说过，“对手是一面镜子，可以照见自己的缺陷。如果没有了对手，缺陷也不会自动消失。对手，可以让你时刻提醒自己：没有最好的，只有更好。”习惯12、善于借助他人力量年轻人要成就一番事业，养成良好的合作习惯是不可少的，尤其是在现代职场中，靠个人单打独斗的时代已经过去了，只有同别人展开良好的合作，才会使你的事业更加顺风顺水。如果你要成为一名高效能的职场人士，就应当养成善于借助他人力量的好习惯。习惯13、换位思考在人际的相处和沟通里，“换位思考”扮演着相当重要的角色。用“换位思考”指导人的交往，就是让我们能够站在他人的立场上，设身处地理解他人的情绪，感同身受地明白及体会身边人的处境及感受，并且尽可能地回应其需要。树立团队精神一个真正的高效能人士，是不会依仗自己业务能力比别人更优秀而傲慢地拒绝合作，或者合作时不积极，倾向于一个人孤军奋战。他明白在一个企业中，只有团队成功，个人才能成功。善于休息休息可以使一个人的大脑恢复活力,提高一个人的工作效能。身处激烈的竞争之中,每一个人如上紧发条的钟表.因此,一名高效能人士应当注意工作中的调节与休息,这不但于自己健康有益,对事业也是大有好处的。及时改正错误一名高效能人士要善于从批评中找到进步的动力.批评通常分为两类,有价值的评价或是无理的责难.不管怎样,坦然面对批评,并且从中找寻有价值、可参考的成分,进而学习、改进、你将获得意想不到的成功。责任重于一切著名管理大师德鲁克认为,责任是一名高效能工作者的工作宣言.在这份工作宣言里,你首先表明的是你的工作态度:你要以高度的责任感对待你的工作,不懈怠你的工作、对于工作中出现的问题能敢于承担.这是保证你的任务能够有效完成的基本条件。不断学习一个人,如果每天都能提高1%,就没有什么能阻挡他抵达成功.成功与失败的距离其实并不遥远,很多时候,它们之间的区别就在于你是否每天都在提高你自己;如果你不坚持每天进步1%的话,你就不可能成为一名高效能人士.让工作变得简单简单一些,不是要你把事情推给别人或是逃避责任,而是当你焦点集中很清楚自己该做那些事情时,自然就能花更小的力气,得到更好的结果.重在执行执行力是决定一个企业成败的关键,同时也是衡量一个人做事是否高效的重要标准.只做适合自己的事找到合适自己的事,并积极地发挥专长,成为行业的能手,是高效能人士应当努力追求的一个目标.把握关键细节精细化管理时代已经到来,一个人要成为一名高效能人士,必须养成重视细节的习惯.做好小事情既是一种认真的工作态度,也是一种科学的工作精神.一个连小事都做不好的人,绝不可能成为一名高效能人士.不为小事困扰我们通常都能够面对生活中出现的危机,但却常常被一些小事搞得垂头丧气,整天心情不快,精神忧闷紧张。一名高效能人士应当及时摆脱小事困扰,积极地面对工作和生活。专注目标美国明尼苏达矿业制造公司(3M)的口号是:写出两个以上的目标就等于没有目标.这句话不仅适用于公司经营,对个人工作也有指导作用。有效沟通人与人之间的交往需要沟通,在公司,无论是员工于员工员工于上司员工与客户之间都需要沟通.良好的沟通能力是工作中不可缺小的,一个高效能人士绝不会是一个性格孤僻的人,相反他应当是一个能设身处地为别人着想充分理解对方能够与他人进行桌有成效的沟通的人。及时化解人际关系矛盾与人际交往是一种艺术,如果你曾为办公室人际关系的难题而苦恼,无法忍受主管的反复无常,看不惯主管的假公济私,那么你要尝试学习如何与不同的人相处,提高自己化解人际矛盾的能力。积极倾听西方有句谚语说：“上帝给我们两只耳朵，却只给了一张嘴巴。”其用意也是要我们小説多听。善于倾听，是一个高效能人士的一项最基本的素质。保持身体健康充沛的体力和精力是成就伟大事业的先决条件。保持身体健康，远离亚健康是每一名高效能人士必须遵守的铁律。杜绝坏的生活习惯习惯有好有坏。好的习惯是你的朋友，他会帮助你成功。一位哲人曾经説过：“好习惯是一个人在社交场合中所能穿着最佳服饰。”而坏习惯则是你的敌人，他只会让你难堪、丢丑、添麻烦、损坏健康或事业失败。释放自己的忧虑孤独和忧虑是现代人的通病。在纷繁复杂的现代社会，只有保持内心平静的人，才能保证身体健康和高效能的工作。合理应对压力身体是革命的本钱，状态是成功的基础。健康，尤其是心理健康，已成为职场人士和企业持续发展的必备保障。学会正确地应对压力就成了高效能人士必备的一项习惯。掌握工作与生活的平衡真正的高效能人士都不是工作狂，他们善于掌握工作与生活平衡。工作压力会给我们的工作带来种种不良的影响，形成工作狂或者完美主义等错误的工作习惯，这会大大地降低一个人的工作绩效。及时和同事及上下级交流工作正确处理自己与上下级各类同事的关系，及时和同事、上下级交流工作，是高效能人士的一项重要习惯。做到上下逢源，正确处理“对上沟通”，与同事保持良好的互动交