Garbage collector question

I have a question about the garbage collection. You cant activate the garbage collector when you want but in JProbe tool you can request it pushing a button. Can i do this in my application?. I tried using System.gc() and Runtime.getRuntime.gc() but i cant get the same result. Any ideas?
Thanks in advance and excuse me, my english is not so good.

In Jprobe if you request a garbage collection you get
a deep garbage collection that release much of the
used heap size. But if i put in my code System.gc()
only a little of space is released.The amount of released memory depends of course on the number of "unused" objects. If you allocate an array of bytes that's allmost the maximum size of the heap the JVM can use and you make it available for garbage collection by releasing the refernce the effect running the garbage collector is much bigger than if you only allocate an array of, let's say 32 bytes, and do the same. A complex GUI application allocates and releases lots of objects so it's possible to release a huge amount of heap space whereas a not so compex application uses fewer objects and there are less object to release by the garbage collector.

Similar Messages

Garbage Collector Questions

Howdy all,
I've got a few questions about flash's garbage collector. I'm building a game and have all elements in a container sprite called _gameContainer.
_gameConatiners contains other sprites such as _hudContainer which contains more containers such as _gameoverContainer, _menuContainer, etc. So there's a whole hierarchy of containers that are all contained in _gameContainer which is added directly to the document class (not the stage btw).
So the whole thing should basically be Stage -> Document Class -> _gameContainer -> etc.
When the player loses or wants to restart the game, I'm removing all event listeners (which are defined as weak, but still rather make sure there's no loose ends), stopping all music/sounds, removing _gameContainer from the stage, and then setting _gameContainer to null.   From there I am re-calling my init function which creates everything (_gameContainer, and everything inside of it, as well as creating all the standard eventlisteners).
Am I doing everything upside down? Is this *a* proper way of restarting a game? Mind you I dont say "the" proper way since I'm sure there's a hundred different ways to do this.
Also, on a separate note... If I have something such as an enemy, I keep all enemy logic contained in the class linked to the movieclip on the stage. Who should be calling add/removechild? Should I be using a factory method that takes care of all this, or should I have the engine create the enemy, and then have the enemy remove itself from stage?   Currently I'm using a mix of both, but generally I'll have a function in the engine/caller add it to stage, then have the class have an ADDED_TO_STAGE event listener. When it comes time to remove the class, I have it call it's own removeself function such as: (_container is a reference to it's container as mentioned above such as _hudContainer)
protected function removeSelf():void
    if(_container.contains(this)) {
        _container.removeChild(this);
    _container.parent.parent.dispatchEvent(new Event(Engine.START_GAME));
Thanks!

Wonderful question Travisism.
The garbage collection is strange. First I'm curious why you lump displayObjects into _gameConatiners. Does _gameConatiners get added to the stage at any point? Why not just add the proper hud at the point its required?
Anyhow. By removing listeners ,removeChild(_gameConatiners), and setting _gameConatiners=null does not mean these classes are killed. null only marks the memory locations as having no more references to them. When this occurs these objects may be removed from memory. Why do I say may, that is because it takes a specific amount of memory utilized to trigger the garbage collection.
Now just merely setting _gameConatiners=null may not ever kill your objects off. You would be required to profile this and make sure they are dieing properly. From the sounds of it you have a lot of inner children.
There is reason to believe that in some cases, when an object is removed from the main stacks that its children will be removed as well. Though, if the inner workings are so large, often the objects within referencing each other effects the way the garbace collection is stating they are still in use. Thus keeping these objects alive.
Its always best to kill off every reference being used. You can do this by ensuring each object in your movieClip class declared a kill method, and continue trickeling down each object. This ensures each object will be properly marked.
As far as your movieClips a factory method is only for the creation of objects, never for the removal.
You're best bet is to have an object that holds all objects on the stage in a collection. When you destroy the game. Itterate through this collection and remove them from the stage there.
This would fit into your engine concept. There is no reason to use a displayObject for that since its just an object. Better Yet use a Vector.<DisplayObject> to optimize this.
Back to your question is this *a* proper way to reset.
Yeah and No. The asnwer is based on the memory usage your application eats, and the amount of time to rebuild all objects. Ideally you should Pool any resources that can be reused versus having to rebuild.
For example. If you have a screen that says Game Over. why would you have to rebuild it on a reset? There is no information that was changed.   Each clip instantiation takes memory allocated and time.
Unfortunately without seeing what you have its difficult to say. But init methods are good and it can be wise to rebuild objects to being again, but as i said it depends.
Lastly, your line:
_container.parent.parent.dispatchEvent(new Event(Engine.START_GAME));
Should not have parent.parent references within. If you are creating a new Event, at least fall back on eventBubbling to allow the event to travel to the parent.parent.
You should never target parents like that in a class. Best practices is to pass in parent.parent as a reference to the class.
What if you were to add one more layer of parents to the _container. Then you would have to continue modifying parent.parent.parent. At least if you bubble the event you dont have to be concerend at all about who listens to it.

Optimization of the JVM memory - Garbage Collector

Hi ,
Just a question about JVM memory management.
There is memory limitation of memory usage limitation (1.6M) in JVM.
Is there any possibility to use "Garbage collector" mechanism to optimize the memory usage?
Or any suggestions for the JVM memory optimization?
Thanks a lot!!!

nicolasmichael wrote:
Hi,
the "memory limitation" does not have anything to do with garbage collection, but with the address space your operating system provides. On a 32bit operating system, your virtual address space is limited to <= 4 GB, depending on your operating system (for example 1.something GB on Windows and 3.something GB on Solaris). No.
Windows 32 bit has a 2 GB application space and can be configured to allow a 3GB space.
The Sun VM does not allow more because of the way that the executable is linked.
[http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4358809]

Possible Bug in Garbage Collector?

Hello all
I'm new to these forums but I searched for this problem and couldn't find exactly the same thing - apologies if I missed something.
I've written an image browser which displays thumbnails, and when you click on a thumbnail it loads the image in a new window. This new window is just a JFrame, with a single JLabel, with an ImageIcon in it, representing the picture. The path name of the picture is passed when this JFrame is created, and the picture is loaded within the JFrame. Therefore, when I close the JFrame, I expect the memory associated with the image to disappear.
This works. However, when I open a fairly large image (around 1500x1500 pixels), and then close the window, the garbage collector doesn't free the memory. After this, if i continue to open windows with smaller images, they too have the same problem. However, this doesn't happen with smaller images until I open a larger image.
I think this is a problem with the garbage collector, is this familiar to anyone? Can anyone help? Unfortunately I can't really paste code since this is a university assignment. But you can try it - just load a jframe with a large picture, close it, and as long as the program runs the memory will not be deallocated.
Any help would be massively appreciated.
Thanks

Since you're not willing to post your code it's very hard to comment.
One question: Are you calling System.gc() after closing these frames? In fact you should probably call it 3 times to make sure the garbage collector takes you seriously. Try this and let us know if you're still showing the leak

JNI / Garbage Collection question

I have a C++ library I am calling into from our application. The question I have is I want the library to return a jintarray or a jstringarray (not sure which yet). If they create that array in the function and then return it to me as the return type, will the Garbage collector automatically free the memory for that array once I am done using it, or do I need to manually free it some how since the array was created in the c code?
Thanks,
Jeffrey Haskovec

Java objects whether they are create in java or JNI are all managed by the VM.

CORBA and garbage collector

Hi,
I�m writing a server with a method create(), which returns a new object supplying a home banking service for the clients.
My question is : when a given client has finished with the home banking object, do I need to call the gc, or is there an efficient one with CORBA (a kind of distributed garbage collector) ?
Thank you in advance

Maybe you heard about Distributed Garbage Collector (DGC)? Don't rely on this, since IIOP does not support this. Use PortableRemoteObject.unexportObject() to make remote objects that are no longer in use available for garbage collection.
Bert

Garbage collector

Bonjour à la communauté Adobe et merci pour les
éventuelles réponses que je trouverai grâce à
vous.
Je relance je pense une fois de plus, comme sur de nombreux
forums, le problème du Garbage Collector.
J'ai un MovieClip crée dynamiquement. Ce MovieClip
contient un objet vidéo contrôlé et géré
dynamiquement via une classe (cette partie n'est pas bien
importante je suppose); bref je voudrais pouvoir supprimer
complètement ce clip, mais même après un
"removeChild(clip)" et un "clip = null", j'entend toujours le son
de la vidéo... ce qui me fait dire qu'il est toujours
matériellement présent, mais pourquoi??
mon code :
var mavideo:MovieClip;
mavideo = new monclip();
addChild(mavideo);
removeChild(mavideo);
mavideo = null;
System.gc();//j'ai même essayé de forcer le Garbage
Collector, sans succès.
Voilà donc ma question globale : comment supprimer
complètement un clip en as3?
Sorry for my bad english, but the question is : how to
completely delete a MovieClip using AS3? If I remove a MovieClip
which include a video, with the code below, i don't see the video
anymore but i can hear the sound... Strange, isn't it?

Bonjour à la communauté Adobe et merci pour les
éventuelles réponses que je trouverai grâce à
vous.
Je relance je pense une fois de plus, comme sur de nombreux
forums, le problème du Garbage Collector.
J'ai un MovieClip crée dynamiquement. Ce MovieClip
contient un objet vidéo contrôlé et géré
dynamiquement via une classe (cette partie n'est pas bien
importante je suppose); bref je voudrais pouvoir supprimer
complètement ce clip, mais même après un
"removeChild(clip)" et un "clip = null", j'entend toujours le son
de la vidéo... ce qui me fait dire qu'il est toujours
matériellement présent, mais pourquoi??
mon code :
var mavideo:MovieClip;
mavideo = new monclip();
addChild(mavideo);
removeChild(mavideo);
mavideo = null;
System.gc();//j'ai même essayé de forcer le Garbage
Collector, sans succès.
Voilà donc ma question globale : comment supprimer
complètement un clip en as3?
Sorry for my bad english, but the question is : how to
completely delete a MovieClip using AS3? If I remove a MovieClip
which include a video, with the code below, i don't see the video
anymore but i can hear the sound... Strange, isn't it?

How does the Garbage Collector handle reference-free objects?

Hi,
I am interested to know how the GC handle's objects created
without a reference.
The reason this has become of interest to me is that I have
created a "Title" class. The Title class animates each letter of
Title.text to appear in a cloud of smoke.
The smoke is a simple particle system class, when a particle
dies it removes it's associated MovieClip so that eventually all
MovieClip's have been destroyed.
Now in the Title class for each letter I do the following
(psuedo-code):
for( Title.text.length) {
CurrentLetter.twAlpha = new Tween( blah, blah, blah); //
object created
with a reference
new Smoke( CurrentLetter.x, CurrentLetter.y); // object
created
without a reference
Although this is technique is not one I would ever have
thought of in a language that doesn't use a garbage collector it is
mentioned in the Tween documentation and my class works as
intended.
The thing is although it works, it always bothers me when I
don't know precisely
why it works!
If it's working due to the short life span of the class in
question and thus simply missing the GC's window then this could be
problematic. If at some point it is still alive when the GC is
called then my class could be prematurely deleted.
Maybe a class which has a reference to an "alive" MovieClip
is immune from GC?
I Hope someone can shed some light on this topic as the GC is
something that is thinly documented to say the least!
:theory
p.s. first post!

Hi,
I would say it would be better use FREE itab at the end of the processing in your code. In the end-of-selection in your code, you can FREE all your itabs that were used in the program. This is one of the good approach of optimizing the memory.
Regards
Vimal

How intelligent is the garbage collector?

Hi all,
I've got a question about how garbage collection works in an ABAP objects context.
If there are no more references an object is cleaned up and the memory released. Fine.
What about an object O1, which in turn creates another object O2. O2 however also contains a refernce to O1.
When the original process completes, this leaves two objects that reference each other, but with no other contact to the 'outside world'. Is the garbage collector intelligent enough to dump them?
Any input appreciated,
Cheers
Mike

Hi,
Thanks for the feedback. I am still not sure - you say 'when the program ends it's part'. This is exactly the point - when the program ends, do the objects remain because they still contain references to each other?
More detail:
The references are public instance attributes of both objects (different classes). I would prefer to use functional methods, but am stuck with public attributes which I'm populating in the constructor.
So a process P declares a local var LV_O1 and does a CREATE OBJECT LV_O1.
In the constructor of O1, it does a
CREATE OBJECT me->ATTR_O2 to populate it's attribute with a reference to an instance of O2.
O2 doesn't need to do a CREATE OBJECT, but assigns a ref to O1 to it's attribute ATTR_O1.
So now O1 and O2 refer to each other by public attributes:
O1->ATTR_O2 and O2->ATTR_O1.
The big question is what happens when process P ends and it's variable LV_O1 ceases to exist?
In case anyone's wondering about the overall wisdom of the design, they have to be public attributes (used in Workflow) and they have to refer to each other as instantiation may also happen the other way around.
Cheers
Mike

Are there any types of Garbage Collector ??

are there any types of Garbage Collector ??

AmitChalwade123456 wrote:
kajbj wrote:
AmitChalwade123456 wrote:
this question was asked to me in interview !! I could not answer thatI doubt that they asked you the question that you first posted, because the answer would be yes.
Did they ask you what different types of garbage collectors that are implemented in the VM?That mean there are types of GC !! can u give some info about themThe answer to that depends on what VM you are talking about, and what version of VM you are talking about. E.g. an IBM VM isn't implemented in the same way as a Sun VM, and a Sun 1.3 VM has other algorithms than an 1.5 VM.

GARBAGE COLLECTOR( NOT ACTIVATING)

I AM CERTIFIED, LEARNED IN THE COURSE THAT THE GARBAGE COLLECTOR IS A SYSTEM THREAD WHICH RUNS AND COLLECTS ALL THE UN-REFERENCED OBJECTS BUT I COULDN'T MANAGED TO ACTIVATE IT:
THE PROBLEM IS DEFINED AS FOLLOWS:-
1. WE KNOW THAT IF WE OVERRIDE THE FINALIZE METHOD OF AN OBJECT THEN IT IS CALLED WHEN THE SPECIFIC OBJECT IS GARBAGE COLLECTED.
THATS WHY I OVERRIDED A CLASS'S FINALIZE METHOD AND ISSUED A PRINTLN STATEMENT
2. THEN AT RUNTIME I INSTANTIATED THE OBJECT OF THAT PARTICULAR CLASS .
3. I SET THE REFERENCE TO NULL.( AT RUNTIME )
4. NOW ACCORDING TO THE DOCUMENTATION THE OBJECTED SHOULD BE GARBAGE COLLECTED AFTER SOMETIME BUT I WAITED FOR A ABOUT TEN MINUTES BUT IT ISN'T.
PLEASE ANSWER THIS QUESTION AN IF POSSIBLE EXPLAIN THE MECHANISM BY WHICH THE FINALIZE METHOD IS CALLED AT RUNTIME
IT SHOULD BE NOTED THAT THIS THREAD RUNS IN LOW MEMORY CONDITIONS BUT SINCE IT IS A LOW PRIORITY THREAD HOW CAN IT MANAGES TO RUN IN LOW MEMORY CONDITIONS

The only purpose finalize should be used for is a last ditch effort to free resources other than memory allocation. That said...
-It should NEVER be used to free a resource that is not automatically freed when the application exits. So for example it could be used to close a socket, but it should not exist when the 'resource' is a file.
-It should NEVER be the only way to free a resource. There is a reason I said "last ditch". The user of the object should have an explicit method to call which frees the resources.
And that said I would never use it regardless even for a last ditch cleanup. The reason for that is that it would tend to hide the improper usage of the class - in other words that the user wasn't calling the correct clean up method. I might use it to put a diagonistic (probably an unchecked exception) which indicates that the resource was not cleaned.
Expanding further on the other comments made here, if you read the spec you will find that the language does not guarantee that finalize will be called. All that it guarantees is that if it is called it will only be called once. In addition finalize can reduce performance because the existance of it might (and probably will) force the garbage collector to do two passes on the object rather than just one.

Garbage Collector in JC 2.2

Help: I am trying to understand how a Passive Garbage Collector (GC) implementation works in Java Card v2.2. As I understand it, Java Card vendors have the option to implement Automatic GC or a Passive GC under version 2.2 or higher.
My question is as follows:
What if object X no longer used, and was instantiate during the install() process:
With Automatic GC: the GC would automatically reclaim memory after the process() method finish executing. If object X has no other references. Also, any other objects without any references would be reclaimed as well.
With Passive GC: In the process() method the developer must call requestObjectDelete(), and before the next APDU request, the JCRE would reclaim memory. Is this right?
What happens requestObjectDelete() is called on an object that still has references? Does it still reclaim it? In either Passive or Automatic GC?
Do any vendors supporting Automatic GC? How about Java Card version 2.2.2?
Thank you for any help
Maguar

What happens requestObjectDelete() is called on an object that still has references? Until now I haven't seen a method called "requestObjectDelete()" (and Google, too).
Are you probably referring to the static method JCSystem.requestObjectDeletion() ?
This method can not be called "on an object". It only allows to explicitly invoking the GC for freeing the memory allocated by objects that can not be accessed anymore.
This solves the problem that current JavaCards are not multi-threaded. Therefore the GC can not be started in background as it does in the J2SE environment.
By calling JCSystem.requestObjectDeletion() a JavaCard applet "voluntary" gives away CPU time to the GC. In single threaded environments this means that the caller (the JavaCard applet) is halted until the GC has finished its work.
Jan

Garbage Collector periodic rate

Hello!
In an application which I'm studying, garbage collector (opportunely configured with command line options) run on a configurable periodic time: this means that every (10 minutes for example) I call method System.gc() in my code.
If I don't explicitily call this method, Java virtual machine will intervene by itself?
Will it intervene only when a threshold amonut of memory is consumed (too many JAVA object instantiated which wait for be freed) ?
Thank you very much in advance
Diego

Does anyone knows what's the difference with Full GC
and why it intervenes ? Because you told it to. You called System.gc().
I don't think that was the question you meant. My guess is you wanted to know why the Concurrent Low Pause Garbage Collector intervened?
Off that first link I gave you was an link to an article that describes the GC output log ( http://java.sun.com/docs/hotspot/gc1.4.2/example.html ). If you read that article it describes what each of the values in the gc output means.
From that article:
[GC [<collector>: <starting occupancy1> -> <ending occupancy1>, <pause time1> secs] <starting occupancy3> -> <ending occupancy3>, <pause time3> secs]
where
<collector> is an internal name for the collector used in the minor collection
<starting occupancy1> is the occupancy of the young generation before the collection
<ending occupancy1> is the occupancy of the young generation after the collection
<pause time1> is the pause time in seconds for the minor collection.
<starting occupancy3> is the occupancy of the entire heap before the collection
<ending occupancy3> is the occupancy of the entire heap after the collection
<pause time3> is the pause time for the entire garbage collection. This would include the time for a major collection is one was done.
The reason the Concurrent Mark Sweep(CMS) starts is also in the first link I gave you. When the Concurrent Garbage Collector thinks you are about to run out of heap it starts the CMS.
1234.306: [GC [1 CMS-initial-mark: 342810K(499712K)] 342906K(524224K), 0.0026879 secs]In your case that was when the used heap reached 342810K out of a current allocated heap of 499712K
You could describe the specific problem you are investigating. Also it would be helpful if you provided the VM parameters you have for starting your application.

Garbage Collector in 5.0

I have nevver known, how the garbage collector internally works. Now a memory problem forces me to understand it. I read several articles but I do not understand them.
I have a simple question:
Is it possible, that my application will get an OutOfMemoryError even if a garbage-collect would free most of the memory?
In other words:
Is it assured, that garbage collector will always run before an OutOfMemoryError occurs?
I have an application, which parses hundreds of MB of data. However it is assured, that parsed data wont be hold in memory for long time. Normally my application would run with less then 64 MB.
In Java 1.4.2 I have not encountered any memory problems. But in Java 5.0 I encountered the following problem:
My application runs a very long period of time. During this time, the memory usage is about 16 MB. After that period the memory usage suddenly increases and does not stop increasing until a OutOfMemory Error occurs (this is mostly about 260 MB if I set -Xmx265m).
I am sure that I do not hold references to that much data in my application.
Why does the garbage collector not free the memory?
Is the garbage collector in 5.0 different from the one in 1.4.2? If yes, can I set the garbage collector to be that one of 1.4.2???
Thanks and regards
Fatih Coskun

Is it assured, that garbage collector will always run
before an OutOfMemoryError occurs?Yes, an OutOfMemoryError is the GC failing to free enough memory.
Why does the garbage collector not free the memory?
Is the garbage collector in 5.0 different from the one
in 1.4.2? If yes, can I set the garbage collector to
be that one of 1.4.2???Tiger (JDK 5.0) has introduced some "ergonomics" based on the machine the application is run on:
http://java.sun.com/j2se/1.5.0/docs/guide/vm/gc-ergonomics.html
Also, you may want to use jconsole and other new tools in tiger:
http://java.sun.com/j2se/1.5.0/docs/tooldocs/index.html#debug
-Alexis
>
Thanks and regards
Fatih Coskun

Garbage collector tuning. Permanent generation

Hi all,
I'm learning about garbage collector tuning.
Why my system always gives for the permanent generation 8192K?
And why is always full with 8191K? Maybe it is full because my application manages an internal java cache but ....
Does it is OK that is always full?, how can I change its size?
[Perm : 8191K->8191K(8192K)], 0.1922860 secs]
I'm using Java(TM) 2 Runtime Environment, Standard Edition (build 1.4.2_04-b05)
Linux SuSE
I'm using the following command
java -XX:+PrintGCDetails -XX:NewRatio=3 -Xss256k -Xms128m -Xmx256m
[Full GC [Tenured: 0K->2206K(98304K), 0.1920700 secs] 24643K->2206K(127808K), [Perm : 8191K->8191K(8192K)], 0.1922860 secs]
[GC [DefNew: 26299K->1168K(29568K), 0.0566740 secs] 28505K->3374K(127872K), 0.0567870 secs]
[GC [DefNew: 27472K->3264K(29568K), 0.0391920 secs] 29678K->6757K(127872K), 0.0392870 secs]
[GC [DefNew: 29567K->3264K(29568K), 0.0756940 secs] 33061K->12212K(127872K), 0.0757840 secs]
Thaks,

Hi!
In the permanent generation you have data like class information and static strings. This data is usually never garbage-collected since it never becomes garbage anyway (it is "permanent data"). Per default, the JVM starts with a very small perm gen (somewhere around 4 MB, I believe, but this may be system specific). The default max size for the perm gen is 64 MB on most systems.
If your application needs more space in the perm gen than initially allocated, the JVM will enlarge the perm gen until your data fits into the perm gen (or the max size is reached). In your case your applications seems to need 8 MB perm space, therefore the JVM enlarges the perm gen until it is 8 MB large.
So, to answer your question, it's totally ok that your perm gen is 8 MB large and always full. There is no need to change its size in your case. If you still want to do it, you can use -XX:PermSize=<initalSize> and -XX:MaxPermSize=<maxSize>. Setting -XX:PermSize=8m may speed up your application start a little since the JVM allocates enough space right in the beginning and doesn't need to enlarge the perm gen afterwards.
Nick.

Garbage collector question

Similar Messages

Maybe you are looking for