A possibility to prevent garbage collection?

inspired by the topic "Why can we force Garbage Collection" i asked myself if it is possible to explicitly prevent the automatic garbage collection of the VM.
regards
~elchaschab

hmm.. you didn't understand my question.
it's not about prevent the VM from freeing unused
objects, it's about preventing it doing it at the
wrong moment (e.g. a highly interactive part of code).No. But Sun's current GC works in smallish increments to reduce the impact. In extremis, you'd have to look at the realtime java project.
As for preventing objects from being reclaimed, even storing a reference to the object isn't sufficient. You have to provide code that convinces the optimiser that the object will actually be used again in a way that the optimise can't conclude is functionally null. Putting it in a list that will be traversed by an on-exit handler, which in turn will pass it to a native method would do it. Not sure whether anything else is sufficient.
Now throw in Reference objects and finalizers, and things really get exciting :(
Sylvia.

Similar Messages

Preventing garbage-collection of a RMIRegistered server object

I am developping a client/server RMI application, and keep facing occasional ObjectNotFioundException: no such object in table, when the client tries to invoke method on the server stub retrived from the RMIRegistry.
The Javadoc and online documentation say this means the server object has been GC'ed since it has been registered in the RMIRegistry.
Following the advice found at: http://www.nabble.com/java.rmi.NoSuchObjectException:-no-such-object-in-table-t260095.html,
I register the server in a RMIRegistry I obtain through LocateRegistry.getRegistry(), and not createRegistry().
But I still face these exceptions.
Assuming the issue is really due to the server object being garbage-collected, I tried to keep a static reference to the server but it didn't help (the Main class was probably garbage-collected itself).
As a last hope, I've set up a "keep-alive" thread in the server VM, that keeps a direct reference to the server object (not the stub), and regularly invokes something on it. With this mechanism I never face the exception.
This solution looks obviously clumsy.
Is there a neater way to prevent garbage collection of the server object?
Note that I use dynamic stubs (Java5-style).

Without seeing some code, I'm not sure what you are doing. Also the link you supplied is broken.
You always need to keep a live reference to your implementation class. How you do this is your business. Using a separate thread is over-kill.
I set a reference to the implementation class in the start up class and use a never ending wait() to make sure the start up class thread (with the main()) lives forever.

Swing Transferhandler prevents garbage collection of one Component

While searching for memory leaks in my app I found out that an object wasn't garbage collected because of a static reference from javax.swing.TransferHandler.
Once an app has called TransferHandler.exportAsDrag, TransferHandler keeps alive one static reference to a SwingDragGestureRecognizer.
    public void exportAsDrag(JComponent comp, InputEvent e, int action) {
        int srcActions = getSourceActions(comp);
        // only mouse events supported for drag operations
     if (!(e instanceof MouseEvent)
                // only support known actions
                || !(action == COPY || action == MOVE || action == LINK)
                // only support valid source actions
                || (srcActions & action) == 0) {
            action = NONE;
        if (action != NONE && !GraphicsEnvironment.isHeadless()) {
         if (recognizer == null) {
          recognizer = new SwingDragGestureRecognizer(new DragHandler());
            recognizer.gestured(comp, (MouseEvent)e, srcActions, action);
     } else {
            exportDone(comp, null, NONE);
....As you can see there is a call to recognizer.gestured(comp, (MouseEvent)e, srcActions, action). This object saves a reference to the component comp.
This means that the last Component for which the exportAsDrag method was called (and the gestured call was reached); and all objects refererred to by the Component can not be garbage collected.
I think in a normal application this will be not much of a problem because it's only a reference to a single Component; but still I think this is not very nice.
Should I report this as a bug somewhere?

Something similar seems to happens to JInternalFrame.lastFocusOwner
Oh well, I guess I shouldn't worry too much about single references; I don't think they immediately cause memory leaks..

Find out references to objects (garbage collection)

Is there an easy way to find out, which references prevent the garbage collector from collecting my old objects, which I expect should be collected? Something like System.out.println(...)

if you just want an object to be garbage collected, just
make sure you de-reference is completely.CMueller obviously doesn't know which references prevent garbage collection so naturally he cannot set those references to null, now can he?
o = null; // sets the value to null and drops all the referencesThat is simply not true. Removing a reference to an object doesn't affect any other references to that object.
Object o1,o2;
//create an object and make o1 reference it
o1=new Object();
//make o2 reference the same object as o1 references
o2=o1;
//now there are two references to the object
//make o1 reference null
o1=null;
//at this point there is still one reference (o2) to
//the object and therefore the object is NOT garbage
//which means that it can NOT be collected by the GC- Marcus Sundman

Garbage collection and closure

I am running a remote script from bridge that opens a complex dialog in photoshop. I need to run the dialog in photoshop because it displays fonts, styles and actions, which are not available in bridge.
When I close the dialog I return to my bridge script. If I repeated open the remote script with the complex dialog I continue to use up resources and the dialog opens more slowly each time.
If I run the remote script directly from the ESTK I still lose reources and it slows down, but not as significantly as when run as a remote script via bridgetalk.
I think this is caused by inner functions in my dialog, which are creating closures, which in turn are preventing garbage collection.
Has anyone experienced this and do you have any tips to prevent the performance degradation?

Rory,
I've never seen that before. In PS, the script that displays the dialog executes, then the engine that ran it supposed to be destroyed. Should be no need for garbage collection. Running the script directly in ESTK still uses BridgeTalk, so I would expect little difference.
I'd be curious to know what's happening because each time you run the script, it should be using a fresh scripting engine in PS. Perhaps there's something preventing PS from releasing the engine when BridgeTalk is involved. It that's the case, it would be a bug.
I do have a suggestion - instead of switching to PS, why not ask PS to give you lists of fonts, styles, and actions? You could write a script that put all three into a an array:
// up here create the arrays
var a = new Array();
a[0] = fontArray;
a[1] = styleArray;
a[2] = actionArray;
a.toSource();
eval'ing the message body in the onResult handler would give you all the info you needed to show your dialog in Bridge. Both Bridge and PS use scriptUI, so the dialog you have written should work in either (once you get the information necessary to display it in Bridge).

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.........................
}

This byte array is not garbage collected?

imageBytes[] does not seem to ever be garbage collected. I've pinpointed a SINGLE LINE that, when commented out, will prevent the memory leak. What could possibly be wrong with this line?
Running this code results in a "OutOfMemoryError: Java heap space" after roughly a minute on my machine. I'm using JRE version 1.5.0_08.
import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.*;
import java.io.*;
// creates images to send to ImageConsumer
public class ImageProducer {
     static BufferedImage bufferedImage;
     static Robot robo;
     static byte[] imageBytes;
     public static void main(String args[]) {
          try {
               robo = new Robot();
          } catch(Exception e) {
               e.printStackTrace();
          PipedOutputStream pos = new PipedOutputStream();
          new ImageConsumer(pos).start();
          bufferedImage = robo.createScreenCapture(new Rectangle(Toolkit.getDefaultToolkit().getScreenSize()));
          try {
               ObjectOutputStream oostream = new ObjectOutputStream(pos);
               ByteArrayOutputStream baos = new ByteArrayOutputStream();
               ImageIO.write(bufferedImage, "JPG", baos);
               baos.flush();
               imageBytes = baos.toByteArray();
               while (true) {
                    ImageIO.write(bufferedImage, "JPG", baos);
                    baos.flush();
                    // THIS SEEMS TO BE WHERE THE MEMORY LEAK OCCURS: imageBytes
                    // If you comment the following line out, there will be no
                    // memory leak. Why? I ask that you help me solve this.
                    imageBytes = baos.toByteArray();
                    baos.reset();
                    oostream.writeObject(imageBytes);
                    pos.flush();
          } catch (Exception e) {
               e.printStackTrace();
// This thread reads the image data into bImg
class ImageConsumer extends Thread {
     BufferedImage bImg;
     PipedInputStream pis;
     ImageConsumer(PipedOutputStream pos) {
          try {
               pis = new PipedInputStream(pos);
          } catch (IOException e) { e.printStackTrace();}
     public void run() {
          try {
               ObjectInputStream oinstream = new ObjectInputStream(pis);
               while (true) {
                    byte[] imageBytes = (byte[])oinstream.readObject();
                    ByteArrayInputStream bais = new ByteArrayInputStream(imageBytes);
                    bImg = ImageIO.read(bais);
          } catch (Exception e) {e.printStackTrace();}
}

while (true) {
     ImageIO.write(bufferedImage, "JPG", baos);
     baos.flush();
     // THIS SEEMS TO BE WHERE THE MEMORY LEAK OCCURS: imageBytes
     // If you comment the following line out, there will be no
     // memory leak. Why? I ask that you help me solve this.
     imageBytes = baos.toByteArray();
     baos.reset();
     oostream.writeObject(imageBytes);
     pos.flush();
}I have only briefly gone through the code, but why are you flushing it right before calling that line. Won't the byte array returned always be empty right after flushing the stream?

High Eden Java Memory Usage/Garbage Collection

Hi,
I am trying to make sure that my Coldfusion Server is optomised to the max and to find out what is normal limits.
Basically it looks like at times my servers can run slow but it is possible that this is caused by a very old bloated code base.
Jrun can sometimes have very high CPU usage so I purchased Fusion Reactor to see what is going on under the hood.
Here are my current Java settings (running v6u24):
java.args=-server -Xmx4096m -Xms4096m -XX:MaxPermSize=256m -XX:PermSize=256m -Dsun.rmi.dgc.client.gcInterval=600000 -Dsun.rmi.dgc.server.gcInterval=600000 -Dsun.io.useCanonCaches=false -XX:+UseParallelGC -Xbatch ........
With regards Memory, the only memory that seems to be running a lot of Garbage Collection is the Eden Memory Space. It climbs to nearly 1.2GB in total just under every minute at which time it looks like GC kicks in and the usage drops to about 100MB.
Survivor memory grows to about 80-100MB over the space of 10 minutes but drops to 0 after the scheduled full GC runs. Old Gen memory fluctuates between 225MB and 350MB with small steps (~50MB) up or down when full GC runs every 10 minutes.
I had the heap set to 2GB initally in total giving about 600MB to the Eden Space. When I looked at the graphs from Fusion Reactor I could see that there was (minor) Garbage Collection about 2-3 times a minute when the memory usage maxed out the entire 600MB which seemed a high frequency to my untrained eye. I then upped the memory to 4GB in total (~1.2GB auto given to Eden space) to see the difference and saw that GC happened 1-2 times per minute.
Is it normal in Coldfusion that the Eden memory would grow so quickly and have garbage collection run so often? i.e do these graphs look normal?
Also should I somehow redistribute the memory available to give the Eden memory more since it seems to be where all the action is?
Any other advice for performance improvements would be much appreciated.
Note: These graphs are not from a period where jrun had high CPU.
Here are the graphs:
PS Eden Space Graph
PS Survivor Space Graph
PS Old Gen Graph
PS Perm Gen Graph
Heap Memory Graph
Heap/Non Heap Memory Graph
CPU Graph
Request Average Execution Time Graph
Request Activity Graph
Code Cache Graph

Hi,
>Is it normal in Coldfusion that the Eden memory would grow so quickly and have garbage collection run so often?
Yes normal to garbage collect Eden often. That is a minor garbage collection.
>Also should I somehow redistribute the memory available to give the Eden memory more since it seems to be where all the action is?
Sometimes it is good to set Eden (Eden and its two Survivor Spaces combined make up New or Young Generation part of JVM heap) to a smaller size. I know your thinking - what make it less, but I want to make it bigger. Give less a try (sometimes less = more, bigger not = better) and monitor the situation. I like to use -Xmn switch, some sources say to use other method/s. Perhaps you could try java.args=-server -Xmx4096m -Xms4096m -Xmn172m etc. I better mention make a backup copy of jvm.config before applying changes. Having said that now you know how you can set the size to bigger if you want.
I think the JVM is perhaps making some poor decisions with sizing the heap. With Eden growing to 1Gb then being evacuated not many objects are surviving and therefore not being promoted to Old Generation. This ultimately means the object will need to be loaded again latter to Eden rather than being referenced in the Old generation part of the heap. Adds up to poor performance.
>Any other advice for performance improvements would be much appreciated.
You are using Parallel garbage collector. Perhaps you could enable that to run multi-threaded reducing the time duration of the garbage collections, jvm args ...-XX:+UseParallelGC -XX:ParallelGCThreads=N etc where N = CPU cores (eg quad core = 4).
HTH, Carl.

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

Remove / unload external swf file(s) from the main flash file and load a new swf file and garbage collection from memory.

I can't seem to remove / unload the external swf files e.g when the carousel.swf (portfolio) is displayed and I press the about button the about content is overlapping the carousel (portfolio) . How can I remove / unload an external swf file from the main flash file and load a new swf file, while at the same time removing garbage collection from memory?
This is the error message(s) I am receiving: "TypeError: Error #2007: Parameter child must be non-null.
at flash.display::DisplayObjectContainer/removeChild()
at index_fla::MainTimeline/Down3()"
import nl.demonsters.debugger.MonsterDebugger;
var d:MonsterDebugger=new MonsterDebugger(this);
stage.scaleMode=StageScaleMode.NO_SCALE;
stage.align=StageAlign.TOP_LEFT;
stage.addEventListener(Event.RESIZE, resizeHandler);
// loader is the loader for portfolio page swf
var loader:Loader;
var loader2:Loader;
var loader3:Loader;
var loader1:Loader;
// resize content
function resizeHandler(event:Event):void {
    // resizes portfolio page to center
loader.x = (stage.stageWidth - loader.width) * .5;
loader.y = (stage.stageHeight - loader.height) * .5;
// resizes about page to center
loader3.x = (stage.stageWidth - 482) * .5 - 260;
loader3.y = (stage.stageHeight - 492) * .5 - 140;
/*loader2.x = (stage.stageWidth - 658.65) * .5;
loader2.y = (stage.stageHeight - 551.45) * .5;*/
addEventListener(Event.ENTER_FRAME, onEnterFrame,false, 0, true);
function onEnterFrame(ev:Event):void {
var requesterb:URLRequest=new URLRequest("carouselLoader.swf");
loader = null;
loader = new Loader();
loader.name ="carousel1"
//adds gallery.swf to stage at begining of movie
loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, ioError);
function ioError(event:IOErrorEvent):void {
trace(event);
try {
loader.load(requesterb);
} catch (error:SecurityError) {
trace(error);
addChild(loader);
loader.x = (stage.stageWidth - 739) * .5;
loader.y = (stage.stageHeight - 500) * .5;
// stop gallery.swf from duplication over and over again on enter frame
removeEventListener(Event.ENTER_FRAME, onEnterFrame);
//PORTFOLIO BUTTON
//adds eventlistner so that gallery.swf can be loaded
MovieClip(root).nav.portfolio.addEventListener(MouseEvent.MOUSE_DOWN, Down, false, 0, true);
function Down(event:MouseEvent):void {
// re adds listener for contact.swf and about.swf
MovieClip(root).nav.info.addEventListener(MouseEvent.MOUSE_DOWN, Down1, false, 0, true);
MovieClip(root).nav.about.addEventListener(MouseEvent.MOUSE_DOWN, Down3, false, 0, true);
//unloads gallery.swf from enter frame if users presses portfolio button in nav
var requester:URLRequest=new URLRequest("carouselLoader.swf");
    loader = null;
loader = new Loader();
loader.name ="carousel"
loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, ioError);
function ioError(event:IOErrorEvent):void {
trace(event);
try {
loader.load(requester);
} catch (error:SecurityError) {
trace(error);
addChild(loader);
loader.x = (stage.stageWidth - 739) * .5;
loader.y = (stage.stageHeight - 500) * .5;
removeChild( getChildByName("about") );
removeChild( getChildByName("carousel1") );
// remove eventlistner and prevents duplication of gallery.swf
MovieClip(root).nav.portfolio.removeEventListener(MouseEvent.MOUSE_DOWN, Down);
//INFORMATION BUTTON
//adds eventlistner so that info.swf can be loaded
MovieClip(root).nav.info.addEventListener(MouseEvent.MOUSE_DOWN, Down1, false, 0, true);
function Down1(event:MouseEvent):void {
//this re-adds the EventListener for portfolio so that end user can view again if they wish.
MovieClip(root).nav.portfolio.addEventListener(MouseEvent.MOUSE_DOWN, Down, false, 0, true);
MovieClip(root).nav.about.addEventListener(MouseEvent.MOUSE_DOWN, Down3, false, 0, true);
var requester:URLRequest=new URLRequest("contactLoader.swf");
loader2 = null;
loader2 = new Loader();
loader2.name ="contact"
loader2.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, ioError);
function ioError(event:IOErrorEvent):void {
trace(event);
try {
loader2.load(requester);
} catch (error:SecurityError) {
trace(error);
addChild(loader2);
loader2.x = (stage.stageWidth - 658.65) * .5;
loader2.y = (stage.stageHeight - 551.45) * .5;
// remove eventlistner and prevents duplication of info.swf
MovieClip(root).nav.info.removeEventListener(MouseEvent.MOUSE_DOWN, Down1);
//ABOUT BUTTON
//adds eventlistner so that info.swf can be loaded
MovieClip(root).nav.about.addEventListener(MouseEvent.MOUSE_DOWN, Down3, false, 0, true);
function Down3(event:MouseEvent):void {
//this re-adds the EventListener for portfolio so that end user can view again if they wish.
MovieClip(root).nav.portfolio.addEventListener(MouseEvent.MOUSE_DOWN, Down, false, 0, true);
MovieClip(root).nav.info.addEventListener(MouseEvent.MOUSE_DOWN, Down1, false, 0, true);
var requester:URLRequest=new URLRequest("aboutLoader.swf");
loader3 = null;
loader3 = new Loader();
loader3.name ="about"
loader3.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, ioError);
function ioError(event:IOErrorEvent):void {
trace(event);
try {
loader3.load(requester);
} catch (error:SecurityError) {
trace(error);
addChild(loader3);
loader3.x = (stage.stageWidth - 482) * .5 - 260;
loader3.y = (stage.stageHeight - 492) * .5 - 140;
removeChild( getChildByName("carousel") );
removeChild( getChildByName("carousel1") );
// remove eventlistner and prevents duplication of info.swf
MovieClip(root).nav.about.removeEventListener(MouseEvent.MOUSE_DOWN, Down3);
stop();

Andrei1,
Thank you for the helpful advice. I made the changes as you suggested but I am receiving a #1009 error message even though my site is working the way I wan it to work. I would still like to fix the errors so that my site runs and error free. This is the error I am receiving:
"TypeError: Error #1009: Cannot access a property or method of a null object reference."
I'm sure this is not the best method to unload loaders and I am guessing this is why I am receiving the following error message.
     loader.unload();
     loader2.unload();
     loader3.unload();
I also tried creating a function to unload the loader but received the same error message and my portfolio swf was not showing at all.
     function killLoad():void{
     try { loader.close(); loader2.close; loader3.close;} catch (e:*) {}
     loader.unload(); loader2.unload(); loader3.unload();
I have a question regarding suggestion you made to set Mouse Event to "null". What does this do setting the MouseEvent do exactly? Also, since I've set the MouseEvent to null do I also have to set the loader to null? e.g.
---- Here is my updated code ----
// variable for external loaders
var loader:Loader;
var loader1:Loader;
var loader2:Loader;
var loader3:Loader;
// makes borders resize with browser size
function resizeHandler(event:Event):void {
// resizes portfolio page to center
     loader.x = (stage.stageWidth - loader.width) * .5;
     loader.y = (stage.stageHeight - loader.height) * .5;
// resizes about page to center
     loader3.x = (stage.stageWidth - 482) * .5 - 260;
     loader3.y = (stage.stageHeight - 492) * .5 - 140;
//adds gallery.swf to stage at begining of moviie
     Down();
//PORTFOLIO BUTTON
//adds eventlistner so that gallery.swf can be loaded
     MovieClip(root).nav.portfolio.addEventListener(MouseEvent.MOUSE_DOWN, Down, false, 0, true);
function Down(event:MouseEvent = null):void {
// re adds listener for contact.swf and about.swf
     MovieClip(root).nav.info.addEventListener(MouseEvent.MOUSE_DOWN, Down1, false, 0, true);
     MovieClip(root).nav.about.addEventListener(MouseEvent.MOUSE_DOWN, Down3, false, 0, true);
//unloads gallery.swf from enter frame if users presses portfolio button in nav
     var requester:URLRequest=new URLRequest("carouselLoader.swf");
     loader = new Loader();
     loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, ioError);
     function ioError(event:IOErrorEvent):void {
     trace(event);
     try {
     loader.load(requester);
     } catch (error:SecurityError) {
     trace(error);
     this.addChild(loader);
     loader.x = (stage.stageWidth - 739) * .5;
     loader.y = (stage.stageHeight - 500) * .5;
// sure this is not the best way to do this - but it is unload external swfs
     loader.unload();
     loader2.unload();
     loader3.unload();
// remove eventlistner and prevents duplication of gallery.swf
     MovieClip(root).nav.portfolio.removeEventListener(MouseEvent.MOUSE_DOWN, Down);
//INFORMATION BUTTON
     //adds eventlistner so that info.swf can be loaded
     MovieClip(root).nav.info.addEventListener(MouseEvent.MOUSE_DOWN, Down1, false, 0, true);
     function Down1(event:MouseEvent = null):void {
     //this re-adds the EventListener for portfolio so that end user can view again if they wish.
     MovieClip(root).nav.portfolio.addEventListener(MouseEvent.MOUSE_DOWN, Down, false, 0, true);
     MovieClip(root).nav.about.addEventListener(MouseEvent.MOUSE_DOWN, Down3, false, 0, true);
     var requester:URLRequest=new URLRequest("contactLoader.swf");
     loader2 = null;
     loader2 = new Loader();
     loader2.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, ioError);
     function ioError(event:IOErrorEvent):void {
     trace(event);
     try {
     loader2.load(requester);
}      catch (error:SecurityError) {
     trace(error);
     addChild(loader2);
     loader2.x = (stage.stageWidth - 658.65) * .5;
     loader2.y = (stage.stageHeight - 551.45) * .5;
loader.unload();
loader2.unload();
loader3.unload();
     // remove eventlistner and prevents duplication of info.swf
     MovieClip(root).nav.info.removeEventListener(MouseEvent.MOUSE_DOWN, Down1);
//ABOUT BUTTON
     //adds eventlistner so that info.swf can be loaded
     MovieClip(root).nav.about.addEventListener(MouseEvent.MOUSE_DOWN, Down3, false, 0, true);
     function Down3(event:MouseEvent = null):void {
     //this re-adds the EventListener for portfolio so that end user can view again if they wish.
     MovieClip(root).nav.portfolio.addEventListener(MouseEvent.MOUSE_DOWN, Down, false, 0, true);
     MovieClip(root).nav.info.addEventListener(MouseEvent.MOUSE_DOWN, Down1, false, 0, true);
     var requester:URLRequest=new URLRequest("aboutLoader.swf");
     loader3 = null;
     loader3 = new Loader();
     loader3.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, ioError);
     function ioError(event:IOErrorEvent):void {
     trace(event);
     try {
     loader3.load(requester);
}      catch (error:SecurityError) {
     trace(error);
     addChild(loader3);
     loader3.x = (stage.stageWidth - 482) * .5 - 260;
     loader3.y = (stage.stageHeight - 492) * .5 - 140;
     loader.unload();
     loader2.unload();
     loader3.unload();
     // remove eventlistner and prevents duplication of info.swf
     MovieClip(root).nav.about.removeEventListener(MouseEvent.MOUSE_DOWN, Down3);
     stop();

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

Howto Force Garbage Collection manually in Oracle Application Server

Hi,
I have a Oracle SOA suite installed on Oracle 10g Application Server. The heap memory for the SOA oc4j container is 2G with a permgen space of 256M. But it looks like there is some memory leak somewhere and the Heap area is getting filled frequently and this causes an *[libopmnoc4j] OC4J ping attempt timed out* and as a result of this the SOA oc4j container gets restarted automatically.
Is there any means by which we can force a Garbage Collection manually so that this automatic restart does not happen.
Kindly let me know if it is possible to trigger a Garbage Collection manually in Oracle Application Server.
Thanks,
Vijay.

We had a similar situation where the oc4j instance will throw OutOfMemoryException and opmn will restart a new instance every 10-12 hours. The JDBC 10.2.0.3 driver has a memory leak in the XA Resource classes. There is a fix available in metalink.

Memory leak in java / forcing garbage collection for unused resource?

Is there any possibility in big programs if not designed properly for leakage of memory?
If say i forget to force garbage collection of unused resouces what will happen?
Even if i am forcing garbage collection how much assurity can be given to do so?
I need answers w.r.t typical programming examples if someone can provide i will be happy.
Or any useful link.
Thanks
Vijendra

Memory leaks are usually much related with C/C++ programming since in that language you have direct access to memory using pointers.
Now, in Java you do not have access to pointers, however you could still tie up your objects in a way that the garbage collection can not remove them.
Basically, the grabage collection will search all the object implementation, and see if they are referenced or not. If not it will free that memory. However if you, somehow in you code allow a reference to your object then the garbage collection will not displose of that object.
An example I can think of is when developing web applications. For example storing objects in the session will mean that you will have a reference to the object from the session, therefore the garbage collection will not free up the meomry taken by those objects untill the session has expired.
That is how I know it... at least that is how they tought it to me!
regards,
sim085

Performance problem due to garbage collection?

Hallo,
we implemented a digital whiteboard with JavaFX: there is a scene (3200 x 2400 px) on which you can draw (insert paths) and add post-its (colored rectangles with paths or string a content). It's possible to drag the post-its around and it's also possible to pan the scene (to reach all parts of the scene which don't fit into the windows).
The application works quite fast even with ca. 50 post-its and lots of skribbles/drawings. But after ca. 20 minutes the application gets a lot slower. Drawing curves (or handwriting) is not really possible anymore as the paths get angular and moving a post-it takes longer and longer.
How is this possible? Is there a problem with the JavaFX garbage collection? Does anyone else have the problem that the application gets slower after a while?
When I close the window and load it again with the same elements it's as quick as in the beginning and slows down after ca. 20 min. again.
Thanks for your help and suggestions what could be the problem!
Raja

I can't really answer...
We can eliminate saturation of scenegraph capabilities since you can reload it again without problem (at start).
Maybe you create lot of temp objects that aren't properly collected?
I suggest to run JVisualVM on your application and watch its memory (and CPU) usage.

Static class garbage collection

Can garbage collector can garbage collect static classes ?.
My doubt is that when you access a static class , that class is loaded through its class loader ( when first time that class is referenced ).
So when did the garbage collector collects this static class ( assume that static class no longer referred ).
Please do more information,
What are the ways to prevent garbage collector for a particular class ( Assume that i m implementing a singleton for my java runtime)
thanks and regards
Renjith.

Can garbage collector can garbage collect static classes ?. Static classes are nothing special in terms of class loading - they are only different in visibility for linking.
Perhaps you mean static members of classes?
My doubt is that when you access a static class ,
that class is loaded through its class loader ( when
first time that class is referenced ). Classes are always loaded through classloaders. Objects of those classes are allocated from the heap, and the object instances refer to the class object.
Objects (either instances, or classes themselves) are garbage collected when they are no longer live (i.e. no live object refers to them). (This is a somewhat recursive definition, and sometimes, you can have cyclic dependencies that make garbage collection tricky, but the GC, while it has to be conservative for correctness, usually gets it right).
So for a static member to be garbage-collected, the class has to be garbage-collected first. The class cannot be GC'ed until all references to it go away (this includes all dynamically allocated objects of that type, and the class loader that loaded that class).
And yes, class loaders can go away, but only if they are created by your program. The system class loader (which is the default classloader you get if you don't create any class loaders of your own) never goes away, so any class loaded from CLASSPATH will never be unloaded.
(As an example, servlet containers - e.g. Tomcat, Weblogic, etc.) allocate one or more classloaders for each webapp. When the webapp is un-deployed, the classloaders are "orphaned", and they, and any classes loaded by them (from the WEB-INF/lib and WEB-INF/classes directories) are unloaded and garbage-collected. (After all the dynamic objects of those classes are GC'ed, of course).
>
So when did the garbage collector collects this
static class ( assume that static class no longer
referred ).
Please do more information,
What are the ways to prevent garbage collector for a
particular class ( Assume that i m implementing a
singleton for my java runtime)
thanks and regards
Renjith.

A possibility to prevent garbage collection?

Similar Messages

Maybe you are looking for