How to encourage jvm to garbage collect?

Hello,
I am working with an application that would benefit from more frequent garbage collection. It is running on a hefty machine, with multiple processors and more than 4 gigs of memory available for the JVM. Right now, we are setting the max heap size to 3 gigs.
The problem is that objects are accumulating, but are not being collected. During a particular operation that I am profiling, over 1 gig of objects are created, but are never collected. If I do a manual garbage collect (using jprofiler), they are all collected. There is no good way to load these objects in another way, or to create fewer objects.
I have spent a few days playing with -XX:MaxNewSize, -XX:NewSize, -XX:MaxHeapFreeRatio, -XX:TargetSurvivorRatio, and even -XX:+UseParNewGC. Unfortunately, I am unable to encourage the JVM to collect these objects automatically.
Are there any tricks that I am missing? Does anyone know any good way to encourage the JVM to collect garbage after a certain threshhold in the new generation?
Thanks,
--Jeff

You can try this!
How do I set the JVM's heap size?
On machines with limited memory (less than 384MB), it is recommended that you set the initial heap size lower than the default. Open the configuration file etc/netbeans.confin a text editor and modify the options in netbeans_default_optionssetting. Decrease the option -J-Xmx128mto -J-Xmx96m and the option -J-XX:MaxPermSize=96mto -J-XX:MaxPermSize=64m. Save the file and restart the IDE.
Bear in mind that UI responsiveness may be affected when the heap utilization gets close to its limit. Should you encounter an OutOfMemoryError, you need to increase Xmx or XX:MaxPermSize back to the default, or even higher.
Similarly when running on a machine with more memory it might be useful to increase the maximum size of the heap, especially when working with larger projects. Use the page linked below to get more details on this topic.
Applies to: NetBeans 4.x, 5.0
Platforms: All

Similar Messages

How to specify when Full Garbage Collections occur in the Old Generation

Hi. We seem to be having a problem with a number of JVMs (1.5.0_17-b04) that run a component of a Document Management application. This component stores a large amount of information in caches which reside in the Old Generation. Although these cache sizes can be somewhat controlled by the application, they are currently taking about 85% of the Old Generation space. Fortunately, very few objects get tenured into the Old Generation - they all are cleaned up in the New Generation space.
The problem we are seeing is that with the Old Generation at 85% full, there are constant full GC's occurring. Since the caches cannot be removed, the system frantically tries to remove objects that can't be removed.
We have three solutions in mind. The first is to increase the memory allocation to the Old Generation so that the caches take a smaller percentage of the available memory allocation. The second would be to decrease the size of the caches; but this is set more by the number of documents in the application and cannot be made much smaller.
The third solution is to configure the JVM so that Garbage Collections in the Old Generation do not occur until the memory is more than a specific percentage of memory in the Old Generation. We would then set this percentage to be higher than the amount of memory being used by the caches.
So, is it possible to tell the JVM to only run a Full GC when the memory in the Old Generation is greater than a specific value (say 85% full)?
Thanks for your help.
Andre Fischer.

afischer wrote:
The third solution is to configure the JVM so that Garbage Collections in the Old Generation do not occur until the memory is more than a specific percentage of memory in the Old Generation. We would then set this percentage to be higher than the amount of memory being used by the caches.
So, is it possible to tell the JVM to only run a Full GC when the memory in the Old Generation is greater than a specific value (say 85% full)?Switch to the CMS collector.
-XX:+UseConcMarkSweepGC
-XX:CMSInitiatingOccupancyFraction=86

How can I prevent class garbage collection????

Hi,
Is there a way to prevent a class from being garbage collected without using the -noclassgc option? Is there some code I can include in a class that tells the JVM not to garbage collect that particular class?
Thanks in advance,
Jacob.

The code shown below (slightly modified from yours) should work correctly on any 1.0.x throught 1.4 JVM.
Look at this article for further info: http://www.javaworld.com/javaworld/javatips/jw-javatip52.html
public class SQLManager extends PoolManager {
    private static SQLManager myself;
    //code.........................
    public static SQLManager getInstance() {
        // This version of a getInstance method suffers from the use of the
        // broken (unreliable) double checked locking idiom. It should never
        // be used on a system with more than one processor and is ill-advised
        // any other time. It can lead to accesses to uninitialized objects.
        // See http://www.javaworld.com/javaworld/jw-02-2001/jw-0209-double.html
        // or http://c2.com/cgi/wiki?DoubleCheckedLockingIsBroken
        // So despite its common appearance in books and pattern repositories,
        // it should not be used.
        if (myself == null) {
            synchronized(SQLManager.class) {
                if (myself == null)
                    myself = new SQLManager();
        return myself;
    private SQLManager() {
        livethread();
        //code.........................
    void livethread()
        System.out.println("##############################################################");
        System.out.println("###################Live Thread called#########################");
        System.out.println("##############################################################");
        Thread thread = new Thread()
            public void run()
                // added this code to ensure that run() actually is getting
                // called
                System.out.println("##############################################################");
                System.out.println("#################### Thread Started ##########################");
                System.out.println("##############################################################");
                Class myClass = SQLManager.class;
                while (true)
                    try
                        synchronized (myClass)
                            myClass.wait();
                    catch (InterruptedException ex)
                        System.out.println("##############################################################");
                        System.out.println("###################Thread interrupted#########################");
                        System.out.println("##############################################################");
                    finally
                        System.out.println("##############################################################");
                        System.out.println("################### Something Happened #########################");
                        System.out.println("##############################################################");
                System.out.println("##############################################################");
                System.out.println("#################### Thread Dead?? ##########################");
                System.out.println("##############################################################");
        thread.setDaemon(true);
        System.out.println("##############################################################");
        System.out.println("#################### Starting Thread #########################");
        System.out.println("##############################################################");
        thread.start();
    //code.........................
}

How to make external SWFs garbage collected in Air for iOS?

My app uses lots of external SWFs( well they are actually included in the app with a folder but they aren't embeded ) and they do not contain any bitmapdata, only vector graphics. The problem I'm having is that they seem to be never garbage collected and System.privateMemory keeps increasing as the app loads more SWFs.
Since those SWFs only contain vector graphics, I simply nullify all the variables that are holding reference to SWF file and call System.gc().. But it doesn't seem to be working. What would I need to do for the garbage collector to clean the SWFs?
I'm using Air for iOS 3.5.0.1060 and ActionScript3.0.

Yes I'm calling System.gc() twice. I tried using loader.unloadAndStop(true) and it seems SWFs are being garbage collected but another problem has surfaced. When repeatedly loading and unloading SWF in a short period, the air garbage collector sometimes fails to work.
I've tested loading and unloading same SWF 50k times and checked trace. Occasionally, garbage collector misses to collect garbage like below( swf #45119 is not being garbage collected).
[UnloadSWF] main.swf/[[DYNAMIC]]/45115
[UnloadSWF] main.swf/[[DYNAMIC]]/45116
[UnloadSWF] main.swf/[[DYNAMIC]]/45117
[UnloadSWF] main.swf/[[DYNAMIC]]/45118
[UnloadSWF] main.swf/[[DYNAMIC]]/45120
[UnloadSWF] main.swf/[[DYNAMIC]]/45121

How to Perm Gen space garbage collected?

Hi,
Im using a small utility to start & stop Embedded Tomcat [both utility & Tomcat are in a single JVM]. The effect of start & stop is that, the classes are not getting unloaded on stopping the Tomcat container & classes are getting reloaded on each & every start,there where no traces of unloading of classes.
So results in Out of Memory Exception : Perm Gen Space.
Trials i had are
1. Called destroy of the Tomcat class loader
2. Used GC option CMSPermGenSweepingEnabled
but no results.
Please let me provide solution.
Thanks in advance,
Edited by: user7362843 on Oct 7, 2010 9:36 PM

What VM are you using?
Classes are unloaded, at least in normal desktop VMs, when the class loader that loaded them is unloaded.
Since you are stating that more than one class of the same type is being loaded that by definition means that you are using class loaders. So allowing those to be collected would allow the old classes to be collected.

How to avoid pauses in Garbage Collection

While doing performance test on a full load we found pauses. We captured GC and here are few instances of Full GC. We are running JVM 1.5, JBoss 4.2.x on RedHat Linux. Could some one guide me in avoiding those 17 secs and 10 sec pauses. Thanks
3643.602: [Full GC   [PSYoungGen: 23948K->0K(155328K)] [PSOldGen: 1819363K->728226K(1864192K)] 1843311K->728226K(2019520K) [PSPermGen: 58042K->58042K(60928K)] 17.8018000 secs]
51867.636: [Full GC   [PSYoungGen: 1176K->0K(165824K)] [PSOldGen: 230161K->227209K(1864192K)] 231337K->227209K(2030016K) [PSPermGen: 58577K->58091K(58496K)] 4.1231000 secs]
5862.403: [Full GC   [PSYoungGen: 41791K->0K(126400K)] [PSOldGen: 1843013K->421307K(1864192K)] 1884805K->421307K(1990592K) [PSPermGen: 58161K->58161K(58624K)] 10.8445660 secs]
62677.562: [Full GC   [PSYoungGen: 1192K->0K(166528K)] [PSOldGen: 229211K->230214K(1864192K)] 230403K->230214K(2030720K) [PSPermGen: 58466K->58466K(58752K)] 2.8801950 secs]

In general you need to use double buffering if you want to avoid flickering. That means that instead of painting directly to the window you paint to a bitmap and then paint that bitmap to the window.
There are probably plenty of articles on the internet about the subject, here's one I found on a quick search:
http://www.codeproject.com/Articles/33/Flicker-Free-Drawing-In-MFC
One thing that may be worth noting is that in some cases most of the flicker comes from the default painting of the window background. In some cases simply avoiding that (see the OnEraseBkgnd change in that articles) removes most of the flicker.

IncompatibleClassChangeError. Caused by garbage collection?

The problem occurs on JDK 1.3.1-b24 compiled in JBuilder Windows and
running on Sun Solaris with identical JDK version.
The application is a relatively complex RMI server.
An error recovery function in the server runs in a Thread every two
minutes. Most of the time it has nothing to do and ends without
incident.
Occasionally conditions require recovery that may not be successful
for many attempts.
Part of the recovery is a simple debug display of parameters involved
in the recovery. There will be multiple displays during a single
recovery cycle.
In a recent example of problem, the recovery executed every two
minutes for over two hours with the debug display working
successfully.
Suddenly one display works successfully and 5 milliseconds later the
same display fails with a IncompatibleClassChangeError.
The last part of the stack trace is:
java.lang.IncompatibleClassChangeError
     at [class name].toString([class name].java:74)
     at java.lang.String.valueOf(String.java:1947)
     at java.lang.StringBuffer.append(StringBuffer.java:370)
     at java.util.AbstractMap.toString(AbstractMap.java:567)
     at java.lang.String.valueOf(String.java:1947)
line 74 of class is
public String toString()
return _responses.toString();
where _responses is an ArrayList that has been stored on Map that
contains the parameters that is being display as part of the debug
information.
Once the failure occurs, it will always occur until the JVM is
restarted. This suggests to me that something in the JVM, maybe garbage collection, has either corrupted the in-memory copy of the class or some internal table used by the JVM has become corrupted.
Anybody else have ideas?

java.lang.IncompatibleClassChangeError
     at [class name].toString([class name].java:74)
     at java.lang.String.valueOf(String.java:1947)
at
java.lang.StringBuffer.append(StringBuffer.java:370)
at
java.util.AbstractMap.toString(AbstractMap.java:567)
     at java.lang.String.valueOf(String.java:1947)
Problem: The IncompatiableClassChangeError is a Symbolic resolution problem. In lamen's terms a package,class,method,or a variable name is corrupted.
Possible problem location: Are you using a Custom ClassLoader? Do you Load and compile on the fly?
where _responses is an ArrayList that has been stored
on Map that
I would look hard at the following methods in your MAP Interface:
public void clear();
public Object put(Object key,Object value);
public void putAll(Map t);
public Object remove(Object key);Is it possible that your MAP interface is corrupting your ArrayList using one of the above methods? Then, when you are building the strings using the AbstractMap's.toString() method, you are getting the IncompatiableClassChangeError?
This is word for word listing of the MAP Interface...V1.41.
Some map implementations have restrictions on the keys and values they may contain. For example, some implementations prohibit null keys and values, and some have restrictions on the types of their keys.
This puzzles me
Attempting to insert an ineligible key or value throws an unchecked exception, typically NullPointerException or ClassCastException.
What's this, they state above that you should get a unchecked Exception, but the first sentence below makes me assume they are pulling a query on an ineligible key or value???
Attempting to query the presence of an ineligible key or value may throw an exception, or it may simply return false; some implementations will exhibit the former behavior and some will exhibit the latter.
Oh,OK. They are basically saying it totally depends on how you implement this Interface <grin>
More generally, attempting an operation on an ineligible key or value whose completion would not result in the insertion of an ineligible element into the map may throw an exception or it may succeed, at the option of the implementation.
The "optional" they are talking about are the methods that I listed above.
Such exceptions are marked as "optional" in the specification for this interface.
Well you asked for ideas, so there's a brain fart for you?
...Hope this helps

Garbage collection

String string1 = "Test";
String string2 = "Today";
string1 = null;
string1 = string2; i want know how many objects have been garbage collected by the JVM in this code .
is there any function of JVM which can tell me how many have been garbage collected for this code.
here its a small code. the reason i am asking , for large code it would difficult to track manually for garbages. . so is there any way out ?

for large code it would difficult to track manually
for garbages. . so is there any way out ?There is an easy way out: stop worrying about it.
You don't need to "track" garbage. That's the beauty of garbage collection. It's mostly automatic (as long as you don't do anything silly in your code, such as build a huge data structure, and keep it stored in a global variable forever even though the program will never use the data again.)
Are you a C++ programmer by any chance? I find that sometimes C++ programmers who run into a garbage collecting system tend to obsess about it needlessly, because so much time and attention has to be spent twiddling with memory allocation in C++.
How many objects does System.gc() collect? Maybe none. Maybe one. Maybe more. System.gc() might not collect anything at all; it might schedule garbage collection to happen at a later time. There are asynchronous garbage collectors that run in their own threads, collecting whenever the cpu has a few spare cycles. Asking "how many objects are collected at point X in the code" makes no sense on those systems.

Applescript: force garbage collection?

Hello
I am trying to call applescript functions (from my cocoa application - using NSAppleScript's -executeAndReturnError), to automate some operations in Microsoft Word.
The problem is that after every Applescript call, the Word operates slower and slower (and i guess finally it won't respond at all). I am calling operations, like "set myvar to all words of current document whose [some conditional]" or "set myvar to all fields of current document whose [some conditional]" (which are memory consuming - on each call Word enumerates all the words of a long document, searches there some matches, etc), and i think that after each call of NSAppleScript's -executeAndReturnError, Word doesn't clean its previous "results", which slows it down with every next call. I wanted to try to do an explicit call of Applescript's garbage collector after each -executeAndReturnError from my Cocoa app, maybe that could eliminate the problem i have.
But i didn't find any info on how to do that. Java, ActionScript - both have System.gc() functions (that launch Garbage collection if it's needed right here and right now). If theres no way to force garbage collecting in AppleScript, maybe someone knows "implicit ways", when AppleScript engine calls it? Like the next iteration of a loop, or some other conditions? Or some timespan, after passing which the GC is called?
What could cause that slowness of Mac:Word? Is it a mistake of Microsoft, or am i forgetting to do something? If someone could advice readings about how applications usually implement Applescript interface "from the inside" (and who is responsible for cleaning the results of each call), i'd be very thankful.
Thanks for any advice!
George

If you really want to see the results you should also run the finalizer
thread on the newly garbage collected objects. It might take up to 2 GC
cycles for the memory to be actually free for new allocation at least on
the Sun JVMs. Maybe the new types of garbage collectors do it better or
more optimized but anyway, the GC would first mark the objects and only
then the finalizer will run to call the finalize method. Then next GC
will free the memory of the finalized objects.
HTH,
Dejan
Dinesh wrote:
Hi Slava Imeshev,
Thanks for immediate response. I agree JVM will do GC at specific interval. But,
I have found that , there is some difference in both of them. If you invoke "Force
Garbage Collection" explicitly, the graph will show the heap memory usage to baseline.
Where in, if you perform System.gc(). It won't make much difference.
Thus why, I want to know what is the code behind the "Force Garbage Collection"
button.
Thanks,
-Dinesh.
"Slava Imeshev" <[email protected]> wrote:
"Dinesh" <[email protected]> wrote in message news:406a8df4$[email protected]..
How can i schedule "Force Garbage Collection" to be done at every
week or daily?.
Can i automate this process instead of manually invoking the button?
GC is already done by JVM automatically.
Why would you want to "schedule" it?
Regards,
Slava Imeshev

Getting memory dump without garbage collection

Hi all.
Does anyone know of a way to get a memory dump from the Sun JVM (version 1.5.0_11 for Windows) without garbage collection occurring first? I've tried the -XX:+PrintClassHistogram option, but this always seems to garbage collect before printing the histogram.
My problem is that I see heap usage increasing very rapidly in the JVM, then garbage collection occurs and reduces memory usage back down to what it was before. However, this results in the JVM spending a large amount of time garbage collecting. I would like to be able to see the contents of the heap before GC occurs.
These are the options I've tried so far:
* Using -XX:+PrintClassHistogram. As mentioned above, this always garbage collects before printing the histogram.
* Using -XX:+HeapDumpOnOutOfMemoryError. The problem is that the JVM always manages to GC before running out of memory, so never dumps the heap.
* Using the jmap tool. Unfortunately I'm running Windows (in production), so this is not available for 1.5.
* Using HPROF. However this seems to slow the JVM down hugely (whenever I use -agentlib:hprof=heap=sites or -agentlib:hprof=heap=dump).
* Using the HeapViewer demo tool that comes with the JVM. This has the same effect as PrintClassHistogram and garbage collects before outputting.
* Using JProfiler. Unfortunately it seems (with the 1.5 JVM anyway) the Concurrent Garbage Collector cannot be used in conjunction with JProfiler (I think this is a JVM TI issue?). With the Parallel GC we don't see the same problem (probably mostly because throughput is crippled with the Parallel GC).
* Using jstat. This only gives us statistics about how much has been garabge collected, not which objects were collected.
Has anybody got any other suggestions?
Thanks.
Neil.

Hi all.
Just an update on this -- I couldn't find any way to do this in Java 1.5 (on Windows).
In Java 1.6 (and maybe in 1.5 on other platforms) jmap will do a heap dump without garbage collecting.
I also came across an open source memory profiling tool called Ariadna (see http://mernst.org/ariadna/) which seems to work quite well. It was only of limited use in Java 1.5 however, since JVM TI doesn't support the concurrent garbage collector in this version.
Hope this is helpful anyway. I'll be trying to get upgraded to 1.6 ASAP!
Thanks.
Neil.

Tracing Garbage Collection

I need to implement a program illustrating the performance loss to java through the automated garbage collection Vs controlling the garbage collection manually using java real time programming.
How can I determine when garbage collection is performed by the virtual machine? For instance could I launch a thread to monitor the garbage collection and return feedback when collection is in progress?
Thanks

I have been using this method on my object to write to a file.
protected void finalize() throws RemoteException {
try{
Date now = new Date();
String s = "Garbage Collection was here\n Date: "+now + " Object: " + this.getName()+"\n";
byte abyte0[] = s.getBytes();
FileOutputStream fileoutputstream = new FileOutputStream("garbageplanner.txt", true);
fileoutputstream.write(abyte0);
fileoutputstream.close();
}catch (Exception e){}
}

Hotspot core dumping during JVM garbage collection ?

We have an application which calls a 3rd party supplied server API which has recently been upgraded to use Java 1.5
We are getting the following error reported by our client application. The application is also now running Java 1.5 but references many classes in jar files which would have quite old code in.
The supplier of the API has stated that the problem requires us to recompile all our jar files using v 1.5 ( including things like jconnect and jms ?!?!? ). This sounds like a bit of a cop-out to me, not to mention being impossible since we don't have the source for things like jconnect.
I suspect that there is a garbage collection problem at the bottom of all this, but I'm not sure how I can "prove" this, nor do I currently have any real clue as to how to fix any GC problem that may exist.
The application is supposed to wait for a message on a MQSeries queue and then transforms it via Xalan XSLT and sends it to a Server application. I've tried playing around with heap sizes etc but that just seems to make it worse. If I leave it at the settings that the previous version used then the client at least manages to process a couple of messages before core dumping. There doesn't seem to be a consistent trigger event to cause the core dump ( it's not a message arriving on a queue for example ) but it does seem to be fairly consistent timewise, i.e. after
Any ideas gratefully accepted.
Here's a logfile excerpt from my applications showing the Hotspot error message :
=====================================================================================
08-Jul-2008 10:01:05 Waiting for messages from COLT.BBFS
08-Jul-2008 10:02:05 Waiting for messages from COLT.BBFS
08-Jul-2008 10:03:05 Waiting for messages from COLT.BBFS
405.815: [GC [PSYoungGen: 17331K->9244K(37632K)] 111702K->103615K(192128K), 0.1615910 secs]
405.977: [Full GC#
# An unexpected error has been detected by HotSpot Virtual Machine:
# SIGBUS (0xa) at pc=0xfe141348, pid=2600, tid=8
# Java VM: Java HotSpot(TM) Server VM (1.5.0_03-b07 mixed mode)
# Problematic frame:
# V [libjvm.so+0x141348]
# An error report file with more information is saved as hs_err_pid2600.log
# If you would like to submit a bug report, please visit:
# http://java.sun.com/webapps/bugreport/crash.jsp
=====================================================================================
The logfile referred to in the error message contains the following.
=====================================================================================
# An unexpected error has been detected by HotSpot Virtual Machine:
# SIGBUS (0xa) at pc=0xfe141348, pid=2600, tid=8
# Java VM: Java HotSpot(TM) Server VM (1.5.0_03-b07 mixed mode)
# Problematic frame:
# V [libjvm.so+0x141348]
--------------- T H R E A D ---------------
Current thread (0x001484d8): VMThread [id=8]
siginfo:si_signo=10, si_errno=0, si_code=1, si_addr=0x0000080f
Registers:
O0=0x00487588 O1=0xfe7d6454 O2=0x000079b0 O3=0x00007800
O4=0x00008868 O5=0x00147d48 O6=0xf8781460 O7=0xfe0f7938
G1=0xe52aaae8 G2=0x00000003 G3=0x00000003 G4=0x001484d8
G5=0xf8781d98 G6=0x00000002 G7=0xf8781d98 Y=0x805683e2
PC=0xfe141348 nPC=0xfe14134c
Top of Stack: (sp=0xf8781460)
0xf8781460: fe786000 00c6ba20 fe10013c e54bab68
0xf8781470: 0000080f e54bab6c 0000080f 00000004
0xf8781480: 00487588 00000134 e54bab6c 00000004
0xf8781490: 00000001 00000000 f87814c0 fe17aef4
0xf87814a0: fe6485b4 fe7d899c 001484d8 0011da40
0xf87814b0: 00148988 00148c10 00148d7c f8781880
0xf87814c0: 007c3389 007c3c0e 00000f87 00008868
0xf87814d0: 00008800 00487588 fe141310 fe7d6454
Instructions: (pc=0xfe141348)
0xfe141338: ec 06 c0 1a 80 a5 a0 00 22 40 00 0a ba 07 60 01
0xfe141348: f2 05 a0 00 ae 0e 60 03 80 a5 e0 03 22 40 00 05
Stack: [0xf8702000,0xf8781d98), sp=0xf8781460, free space=509k
Native frames: (J=compiled Java code, j=interpreted, Vv=VM code, C=native code)
V [libjvm.so+0x141348]
V [libjvm.so+0x17aefc]
V [libjvm.so+0x2d557c]
V [libjvm.so+0x300ef8]
V [libjvm.so+0x301e84]
V [libjvm.so+0x2ff950]
V [libjvm.so+0x29df30]
V [libjvm.so+0x362b44]
V [libjvm.so+0x6436f0]
VM_Operation (0xe03012b0): parallel gc system gc, mode: safepoint, requested by thread 0x0031bca0
--------------- P R O C E S S ---------------
Java Threads: ( => current thread )
0x00b2c028 JavaThread "Thread-4" [_thread_in_native, id=85]
0x007f5048 JavaThread "Thread-0" [_thread_blocked, id=84]
0x00c27cf0 JavaThread "Notification Delivery" [_thread_blocked, id=81]
0x0026fa08 JavaThread "RMI LeaseChecker" daemon [_thread_blocked, id=73]
0x00821048 JavaThread "RMI RenewClean-[162.11.2.32:44425]" daemon [_thread_blocked, id=70]
0x0031bca0 JavaThread "GC Daemon" daemon [_thread_blocked, id=67]
0x00cd5d28 JavaThread "RMI Reaper" [_thread_blocked, id=66]
0x003c9300 JavaThread "Timer-0" daemon [_thread_blocked, id=65]
0x00929fe0 JavaThread "RMI TCP Accept-0" daemon [_thread_in_native, id=64]
0x0089bf18 JavaThread "SeedGenerator Thread" daemon [_thread_blocked, id=42]
0x00c47248 JavaThread "Pool thread #7" daemon [_thread_blocked, id=38]
0x00c466a0 JavaThread "Pool thread #6" daemon [_thread_blocked, id=37]
0x00311850 JavaThread "Pool thread #5" daemon [_thread_blocked, id=36]
0x00287a40 JavaThread "Pool thread #4" daemon [_thread_blocked, id=35]
0x00286e98 JavaThread "Pool thread #3" daemon [_thread_blocked, id=34]
0x00c134b0 JavaThread "Pool thread #2" daemon [_thread_blocked, id=33]
0x00ad09e0 JavaThread "Pool thread #1" daemon [_thread_blocked, id=32]
0x00286cd8 JavaThread "PoolThreadManager" daemon [_thread_blocked, id=31]
0x00c129e0 JavaThread "Channel Reaper" daemon [_thread_blocked, id=30]
0x00c669e8 JavaThread "ORB Daemon Thread" daemon [_thread_blocked, id=29]
0x00b10170 JavaThread "Worker for ServerProtocol: (iiop) /0.0.0.0:20168" daemon [_thread_blocked, id=22]
0x008a17e0 JavaThread "Syn~ Client" daemon [_thread_blocked, id=21]
0x003dc378 JavaThread "PoolScavenger0" daemon [_thread_blocked, id=20]
0x0015a928 JavaThread "Low Memory Detector" daemon [_thread_blocked, id=15]
0x00159880 JavaThread "CompilerThread1" daemon [_thread_blocked, id=14]
0x00158a18 JavaThread "CompilerThread0" daemon [_thread_blocked, id=13]
0x00157b98 JavaThread "AdapterThread" daemon [_thread_blocked, id=12]
0x00156dc8 JavaThread "Signal Dispatcher" daemon [_thread_blocked, id=11]
0x0014ccd8 JavaThread "Finalizer" daemon [_thread_blocked, id=10]
0x0014ad90 JavaThread "Reference Handler" daemon [_thread_blocked, id=9]
0x00038238 JavaThread "main" [_thread_in_native, id=1]
Other Threads:
=>0x001484d8 VMThread [id=8]
0x0015c3b0 WatcherThread [id=16]
VM state:at safepoint (normal execution)
VM Mutex/Monitor currently owned by a thread: ([mutex/lock_event])
[0x00037728/0x00037758] Threads_lock - owner thread: 0x001484d8
[0x00033650/0x00037ba8] Heap_lock - owner thread: 0x0031bca0
Heap
PSYoungGen total 37632K, used 9244K [0xf2eb0000, 0xf7ba0000, 0xf8400000)
eden space 28352K, 0% used [0xf2eb0000,0xf2eb0000,0xf4a60000)
from space 9280K, 99% used [0xf4a60000,0xf5367080,0xf5370000)
to space 25216K, 0% used [0xf6300000,0xf6300000,0xf7ba0000)
PSOldGen total 154496K, used 94371K [0xe8400000, 0xf1ae0000, 0xf2eb0000)
object space 154496K, 61% used [0xe8400000,0xee028e78,0xf1ae0000)
PSPermGen total 35584K, used 18260K [0xe4400000, 0xe66c0000, 0xe8400000)
object space 35584K, 51% used [0xe4400000,0xe55d5158,0xe66c0000)
Dynamic libraries:
0x00010000      /dsdvlp/java/jvm/jdk1.5.0_03/bin/java
0xff350000      /usr/lib/libthread.so.1
0xff340000      /usr/lib/libdl.so.1
0xff200000      /usr/lib/libc.so.1
0xff390000      /usr/platform/SUNW,Sun-Fire-880/lib/libc_psr.so.1
0xfe000000      /dsdvlp/java/jvm/jdk1.5.0_03/jre/lib/sparc/server/libjvm.so
0xff1e0000      /usr/lib/libsocket.so.1
0xff2d0000      /usr/lib/libsched.so.1
0xff1b0000      /usr/lib/libCrun.so.1
0xff160000      /usr/lib/libm.so.1
0xff080000      /usr/lib/libnsl.so.1
0xff060000      /usr/lib/libmp.so.2
0xff030000      /dsdvlp/java/jvm/jdk1.5.0_03/jre/lib/sparc/native_threads/libhpi.so
0xfdfc0000      /dsdvlp/java/jvm/jdk1.5.0_03/jre/lib/sparc/libverify.so
0xfdf80000      /dsdvlp/java/jvm/jdk1.5.0_03/jre/lib/sparc/libjava.so
0xfdf50000      /dsdvlp/java/jvm/jdk1.5.0_03/jre/lib/sparc/libzip.so
0xfb7e0000      /usr/lib/locale/en_GB.ISO8859-1/en_GB.ISO8859-1.so.2
0xe4190000      /dsdvlp/java/jvm/jdk1.5.0_03/jre/lib/sparc/libnet.so
0xe3bd0000      /dsdvlp/lib/5/libSolarisNatives.so
0xe3e90000      /dsdvlp/java/jvm/jdk1.5.0_03/jre/lib/sparc/librmi.so
VM Arguments:
jvm_args: -Djava.ext.dirs=/dsdvlp/java/tmijar/firs7/lib/cli:/dsdvlp/java/tmijar/firs7/lib/cli/ext:/dsdvlp/java/tmijar/firs7/lib/cmn/OpenORB:/dsdvlp/java/tmijar/firs7/lib/cmn/OpenORB/ext:/dsdvlp/java/tmijar/firs7/lib/cmn:/dsdvlp/java/tmijar/firs7/lib/cmn/ext:/dsdvlp/java/tmijar/firs7/daemonlib -Duser.dir=/dsdvlp/java/tmijar/firs7 -Dopenorb.config=file:/dsdvlp/java/tmijar/firs7/configs/OpenORB/config/SynOpenORB.xml -Dopenorb.home=file:/dsdvlp/java/tmijar/firs7/configs/OpenORB -Dcom.coexis.syn.general.orbbinding=com.coexis.syn.general.orbbinding.openorb.OpenORBBinding_1_4 -Dsun.rmi.dgc.client.gcInterval=360000 -Dsun.rmi.dgc.server.gcInterval=360000000 -Xms32m -Xmx256m -Dcom.coexis.syn.clientcommandsconfiglocation=file://localhost//dsdvlp/java/tmijar/firs7/configs/clientcommands.xml -Dcom.coexis.syn.clientconfiglocation=file://localhost//dsdvlp/java/tmijar/firs7/configs/fsbbtd_client.xml -XX:+PrintGCTimeStamps -XX:+PrintGCDetails
java_command: com.coexis.syn.mqmessaging.daemon.RunDaemon -p /dsdvlp/bin/5/lndsfsd_fsbbtd.properties start
Environment Variables:
JAVA_HOME=/dsdvlp/java/jvm/jdk150
CLASSPATH=.:/dsdvlp/java/jar/jconnect520.jar:/dsdvlp/java/jar/vbjapp340.jar:/dsdvlp/java/jar/vbjorb340.jar:/dsdvlp/java/jar/javax_jndi120.jar
PATH=/usr/local/etc:/usr/lang:/usr/openwin/bin:/usr/ucb:/bin:/usr/etc:/usr/local/5/bin:/dsdvlp/bin/5:/dsdvlp/bin/4:/home/app/sybase/5/bin:/home/app/sybase/5/localscripts:/home/app/sybase/5/sqr:/home/app/lang:/home/app/lang/SC2.0.1:/usr/ccs/bin:/usr/local/opt/Acrobat3/bin:/dsdvlp/bin:.
LD_LIBRARY_PATH=/dsdvlp/java/jvm/jdk1.5.0_03/jre/lib/sparc/server:/dsdvlp/java/jvm/jdk1.5.0_03/jre/lib/sparc:/dsdvlp/java/jvm/jdk1.5.0_03/jre/../lib/sparc:/usr/lib:/usr/openwin/lib:/usr/local/5/lib:/dsdvlp/lib/5:/dstest/lib/5:/home/app/sybase/5/lib:/dstest/cats/sun4/lib:/tmitest/Opus/opus/lib
SHELL=/bin/csh
DISPLAY=CLI00184.mfil.local:1.0
OS=5
--------------- S Y S T E M ---------------
OS: Solaris 8 2/02 s28s_u7wos_08a SPARC
Copyright 2002 Sun Microsystems, Inc. All Rights Reserved.
Assembled 18 December 2001
uname:SunOS 5.8 Generic_117350-20 sun4u (T1 libthread)
rlimit: STACK 8192k, CORE 9216k, NOFILE 4096, AS infinity
load average:2.24 2.67 2.68
CPU:total 4 has_v8, has_v9, has_vis1, has_vis2, is_ultra3
Memory: 8k page, physical 8388608k(166384k free)
vm_info: Java HotSpot(TM) Server VM (1.5.0_03-b07) for solaris-sparc, built on Apr 13 2005 03:31:26 by unknown with unknown Workshop:0x550

The very first suggestion I have is to move your VM to a more recent update of 1.5.0.
It looks like you are crashing with 5.0u3, and I'm pretty sure 5.0u16 is available. You
don't want to waste your time chasing a bug that's already been fixed.

How to Change the Garbage Collection Algorithm in WLS 9..2

Hi All
I am trying to find out the way to configure the GC algorithm in weblogic 9.2 to type bea.Jmapi.GarbageCollector@.
By default it is showing ‘Nursery, parallel mark, parallel sweep’ . We were trying to change it to generational (two-spaced) with a parallel mark algorithm and a concurrent sweep algorithm or bea.Jmapi.GarbageCollector .
To change the same I modified the memory argument in commenv.cmd to set MEM_ARGS=-Xms128m -Xmx256m -XXsetGC:genparcon
Still Garbage Collection Statistics section in web logic console shows the same default value.
Could anyone tell me if I am missing something?
thanks in advance

There is nothing is WebLogic that will define the JVM GC algorithm, that is up to the JVM settings that are normally configured using params in the start scripts.
If you are using JRockit, you can ask in the forums but the JVM documentation should really be sufficient.
JRockit
Same thing for the Sun JVM, there is lots of information out there on how to change the GC algorithm.
The thing that is nice about JRockit is that you can use the Mission Control tooling to take recordings, look at the GC's and make adjustments easily. Sun has some tooling as well with jvmstat (and visualgc), but I'm not as familiar with it.
http://java.sun.com/performance/jvmstat/
Both of those tools would be much preferred to printing the GC info to a file and trying to parse it in my opinion.

Oracle JVM Garbage Collection not executing

I am experiencing a problem with garbage collection when running a java stored procedure in an 9.2.0.3.0 Oracle database running on a Windows 2k computer.
I have created a simple java class that represents a tree structure. Each instance of the class has a reference to it's parent and a Vecotor of all it's children. Each instance also has a Vector to hold name value pairs. I ran a program that creates 30 instances with 50 children each for a total of 1500 instances. Each instance has 30 properties(name value pairs).
By using the debugger in JDeveloper and breakpoints I can watch the javaw.exe process's use of RAM.
Start up: 6,788mb
After creation of 1500 instances: 17,720
After releasing all objects and calling System.gc(): 7,156
I deploy the package to my Oracle database and perform the exact same routine using breakpoints and test procedures in plsql Developer. Using the breakpoints and watching the oracle.exe process's use of RAM I see:
Start up: 81,116mb
After creation of 1500 instances: 94,952
After releasing all objects and calling System.gc(): 95,036
When run in Oracle the resources are not released. Is there somthing special that needs to be called to get the garbage collector to do it's job when running in an Oracle database?
Execution Instructions and source:
run app.main from jdeveloper and app.main2 as a plsql stored procedure. I have included my test procedure at the end and the plsql stored procedure package declarations. I used debuggers and breakpoints to watch the process, there is probably a way to do this by outputting the current memory being used by I didn't know how. If you use debuggers and breakpoints then when running in JDeveloper put your breakpoints on the 3 assignments of breakpointVar in SimpleClass.main(...). When running the stored procedure test block put them on the 3 assignments of breakpoint_var in there.
package mypackage2;
public class app {
private static SimpleClass topObject;
public static void main(String[] args) {
int breakpointVar;
breakpointVar = 0;
main2(30, 50);
breakpointVar = 1;
release();
breakpointVar = 2;
public static void main2(int numParents, int numChildren){
SimpleClass temp;
SimpleClass child;
topObject = new SimpleClass();
for(int i = 0; i < numParents; i ++){
temp = new SimpleClass();
addProperties(temp, 30);
topObject.addChild(temp);
for(int j = 0; j < numChildren; j++){
child = new SimpleClass();
addProperties(child, 30);
temp.addChild(child);
public static void release(){
topObject.releaseAllDecendents();
topObject.release();
System.gc();
private static void addProperties(SimpleClass toAddTo, int numProps){
cimxProperty toAdd;
for(int i = 0; i < numProps; i ++){
toAdd = new cimxProperty("prop "+i,"value "+i);
toAddTo.addProperty(toAdd);
package mypackage2;
import java.util.Vector;
public class SimpleClass {
private Vector _children;
private Vector _props;
private SimpleClass _parent;
public SimpleClass() {
_children = new Vector(10, 5);
_props = new Vector(10, 5);
_parent = null;
public void addChild(SimpleClass toAdd) {
toAdd._parent = this;
_children.add(toAdd);
public SimpleClass getChild(int index){
return (SimpleClass)_children.get(index);
public void addProperty(cimxProperty toAdd){
_props.add(toAdd);
public cimxProperty getProperty(int index) {
return (cimxProperty)_props.get(index);
public void releaseAllDecendents()
SimpleClass temp;
//remove all references to the the parent object from the children.
for(int i = 0; i < _children.size(); i ++)
temp = (SimpleClass)this._children.get(i);
temp.releaseAllDecendents();
temp._parent = null;
temp._props.clear();
temp._children.clear();
temp = null;
this._children.clear();
public void release() {
this._parent = null;
this._children.clear();
this._props.clear();
package mypackage2;
public class cimxProperty
private static String _dateFormat = "MM/DD/YYYY HH:MI:SS";
private String name;
private String value;
private String dataType;
public cimxProperty()
name = "";
value = "";
dataType = "";
public cimxProperty(String Name, String Value)
name = Name;
value = Value;
dataType = "UNKNOWN";
public cimxProperty(String Name, String Value, String DataType)
name = Name;
value = Value;
dataType = DataType;
public String toString()
return name + "["+dataType + "]: " + value;
public void setName(String name)
this.name = name;
public String getName()
return name;
public void setValue(String value)
this.value = value;
public String getValue()
return value;
public void setDataType(String DataType)
this.dataType = DataType;
public String getDataType()
return dataType;
CREATE OR REPLACE PACKAGE JAVA_MEMORY_TEST AUTHID CURRENT_USER AS PROCEDURE release; PROCEDURE main2(p_num_parents IN NUMBER, p_num_children IN NUMBER); END JAVA_MEMORY_TEST;
CREATE OR REPLACE PACKAGE BODY JAVA_MEMORY_TEST AS PROCEDURE release AS LANGUAGE JAVA NAME 'mypackage2.app.release()'; PROCEDURE main2(p_num_parents IN NUMBER, p_num_children IN NUMBER) AS LANGUAGE JAVA NAME 'mypackage2.app.main2(int, int)'; END JAVA_MEMORY_TEST;
declare
number breakpoint_var
begin
-- Call the procedure
breakpoint_var := 0;
java_memory_test.main2(30, 50);
breakpoint_var := 1;
java_memory_test.release();
breakpoint_var := 2;
end;

When run in Oracle the resources are not released. Is there somthing special that needs to
be called to get the garbage collector to do it's job when running in an Oracle database?Curious - I was always under the impression that you can not force garbage collection. All you could do was request it, and the JVM was free to do that when it was "good 'n ready", usually in a separate thread.
I gather this from the API docs for system.gc() where it says "Calling this method suggests that the Java virtual machine expend effort ..." and the word "suggests" imlies that it is not required to run.

How strong ,soft ,weak ,phantom references are used in garbage collection

Hi
to all here.I have doubt that how garbage collection is deciding to cleaning up heap , and what are the roles of strong , soft , weak and phantom reference in garbage collection, i went throgh sun's java docs but i couldn't get any clear idea about those , please can anyone explain me with nice examples for which i will be really thankful.

See:
http://java.sun.com/developer/technicalArticles/ALT/RefObj/

How to encourage jvm to garbage collect?

Similar Messages

Maybe you are looking for