"Third, a garbage collector used handles to refer indirectly to objects in memory. Those handles were thought to expedite and simplify object relocation during garbage collection; however, they proved to be a significant performance bottleneck. The inability to relocate objects caused significant memory fragmentation and prevented the use of more sophisticated GC algorithms. Other collectors used handleless objects, but when relocated objects were collected, all other objects had to be scanned so that pointers to relocated objects could be updated."
""Aha," you may say, "Chuck is against garbage collectors!" That is not correct because I have also tracked down too many bugs where I knew I wasn't going to use another piece of memory again so I freed the allocated memory, only to modify the code at some later date without that knowledge and in the process introduce a bug by using memory I had already freed. Further, the "cost" or time penalty of running a garbage collection thread (which needs only access memory) is greatly reduced on a fast processor that is spending most of its time waiting for activity on the keyboard or disk drive. In the final analysis, I prefer garbage-collected systems over non-collected systems like C much the same that I prefer C over assembly language. I can spend less time thinking about the mechanics of programming and more time concentrating on the program itself."
"This article does not describe an official Java garbage-collected heap, because none exists. The JVM specification says only that the heap of the Java virtual machine must be garbage collected. The specification does not define how the garbage collector must work. The designer of each JVM must decide how to implement the garbage-collected heap. This article describes various garbage collection techniques that have been developed and demonstrates a particular garbage collection technique in an applet."
"Take out the trash! When it's applied to computer languages, that command conjures up a different meaning than the one you're used to. In Java, trash, or garbage, is heap memory that a program allocates for objects but no longer references; such memory serves no useful purpose. Just as real-world garbage clogs a trash bin, as Java's garbage piles up, it reduces the total amount of heap memory. If the JVM does not remove that garbage, the JVM eventually runs out of heap memory and can't fulfill future program requests to allocate memory for new objects. To prevent that from happening, the JVM takes out the trash through its use of garbage collection."
"Java's garbage collection features tend to confuse new developers. I wrote this two-part series on garbage collection to dispel that confusion. Part 1 introduced you to garbage collection, explored various garbage collection algorithms, showed you how to request that Java run the garbage collector, explained the purpose behind finalization, and mentioned resurrection -- a technique for bringing objects back from the dead. Part 2 explores the Reference Objects API."
"This Java tip shows you how to use reference objects, introduced in JDK 1.2, to solve this problem. By interacting with the garbage collector, you can eliminate loiterers and lapsed listeners, terms suggested by Ed Lycklama (see the Resources section below for more details). Lycklama generally defines a loiterer as an object that persists past its usefulness. The loiterer category is further broken down into four patterns; most common is the lapsed listener, an object added to, but never removed from, a collection of listeners."
"GC Portal is a JavaTM 2, Enterprise Edition (J2EETM) application available as a J2EE WAR module which can run on any J2EE Application Server. The instructions included here specify the steps and requirements to install and run the GC Portal within Sun ONE Application Server 7 or Tomcat servers, on the SolarisTM Operating System (Solaris OS) and on Windows."
"Step 5. Set up the GC Portal database GC Portal can be configured to work with any database including Oracle, MySQL, others, if the appropriate JDBC drivers are available. The steps here describe how to configure it with Pointbase, the default database bundled with S1AS7."
"GC Portal is a Java 2 platform, Enterprise Edition (J2EE) application available as a J2EE WAR module which can run on any J2EE Application Server. The instructions included here specify the steps and requirements to install and run the GC Portal on Sun Java System Application Server 7 and the Solaris Operating Environment or 9 or Red Hat Linux 7.2 or higher."
"Note: This article covered only two types of issues that arise when using finalization: memory- and resource-retention issues. The use of finalization and the Reference classes can also cause very subtle synchronization problems. See Hans-J. Boehm's 2005 JavaOne Conference slides, Finalization, Threads, and the Java Technology-Based Memory Model, for a good overview of these issues."
"This article was first published under the name Under the Hood: Java's garbage-collected heap in JavaWorld, a division of Web Publishing, Inc., August 1996."
"One of the potential disadvantages of garbage collection compared to the explicit freeing of objects is that garbage collection gives programmers less control over the scheduling of CPU time devoted to reclaiming memory. It is in general impossible to predict exactly when (or even if) a garbage collector will be invoked and how long it will take to run. Because garbage collectors usually stop the entire program while seeking and collecting garbage objects, they can cause arbitrarily long pauses at arbitrary times during the execution of the program. Such garbage collection pauses can sometimes be long enough to be noticed by users. Garbage collection pauses can also prevent programs from responding to events quickly enough to satisfy the requirements of real-time systems. If a garbage collection algorithm is capable of generating pauses lengthy enough to be either noticeable to the user or make the program unsuitable for real-time environments, the algorithm is said to be disruptive. To minimize the potential disadvantages of garbage collection compared to the explicit freeing of objects, a common design goal for garbage collection algorithms is to minimize or, if possible, eliminate their disruptive nature."
"Generational garbage collection turns out to be very effective, although it introduces several additional bookkeeping requirements at runtime. In next month's Java theory and practice, we'll explore how generational garbage collection works and how it is employed by the 1.4.1 JVM, in addition to all the other garbage collection options offered by the 1.4.1 JVM. In the installment following that, we'll look at the performance impact of garbage collection, including debunking some performance myths related to memory management."
"Garbage collection (GC) in the IBM Developer Kit for the Java 5.0 Platform (IBM SDK) can be configured using four different policies. This article, the first of two parts on GC, introduces the different garbage collection policies and discusses their general characteristics. You should have a basic understanding of garbage collection in the Java platform before you begin. Part 2 presents a quantitative approach to choosing a policy, along with with some examples."
"The garbage collection implementation is key to the superior performance of the IBM Java Virtual Machine (JVM). While most other JVMs need a lot of tweaking to provide optimal performance, IBM JVMs are designed to work well in most scenarios with their "out of the box" settings. In certain situations, however, garbage collection performance nosedives for no apparent reason. The effects can be an unresponsive server, a frozen screen, or a complete failure, often with cryptic messages such as "Totally out of heap space." Luckily, in almost all such situations, the cause is easy to locate and usually quite easy to correct."
"I hope you found this series about the IBM Java Garbage Collector useful. Part 1 discussed how objects are allocated in the Java heap. Part 2 reviewed how garbage collection works, and covered the three main phases: mark sweep, and compact. This article delved into verbosegc and other command line parameters. Dealing with garbage isn't always easy, but the IBM Java Garbage Collector allows for sensible sanitation."
"We hope this article and the one previous to it have helped you better understand how garbage collection works in the IBM SDK. Future articles will look at other aspects of the IBM implementation of Java technology, including class sharing and debugging, monitoring, and profiling capabilities."
"In the early days of Java technology, allocating objects got a pretty bad rap. There were lots of articles (including some by this author) advising developers to avoid creating temporary objects unnecessarily because allocation (and the corresponding garbage-collection overhead) was expensive. While this used to be good advice (in situations where performance was significant), it is no longer generally applicable to all but the most performance-critical situations."
"There is one possible justification for this call. Without it, GC will not run until the heap is exhausted. If you have a gigabyte heap, you'll take a considerable hit while GC sweeps up all the garbage, and you may consider forcing a GC cycle at regular intervals to get a "little and often" effect. However, you are better off, in this case, considering adjusting heap sizes."
"Sam Borman joined IBM in 1984 after working at seven other companies as a programmer and systems programmer in the UK, New Zealand, and France. He worked as a developer, and later as a development manager, in CICS. In 1990 he returned to a technical career working on CICSPlex/SM and later on DirectTalk. In 1999 he joined the Java Technology Centre where he took ownership of Garbage Collection. You can contact Sam Borman at sambo@uk.ibm.com."
"If you make the effort to look at verbose GC logs, you will often be rewarded with a better understanding of your application characteristics; you'll also be able to detect potentially serious problems with the application's memory usage and improve performance. The IBM Monitoring and Diagnostic Tools for Java - Garbage Collection and Memory Visualizer is a powerful tool for getting the most out of the information available in the verbose GC."
"Languages like C++ force developers to manually allocate and de-allocate memory space for objects, creating extra work for developers and allowing the possibility of leaks. Memory leaks, for those who haven't experienced them, occur when memory for an object is not de-allocated by programmers leading to the gradual depletion of memory resources. Java takes all the pain out of memory management by automatically reclaiming memory. Understanding how automatic garbage collection works is important, as programmers can influence when garbage collection occurs and which objects are destroyed. Without a clear comprehension of garbage collection, your software may not be running at peak performance and may be consuming more memory than is needed."
