Garbage collector don't works.

Hello people !
When I restart the weblogic server this do not shows the lastest change that I made. I think the problem is related to the garbage collector and its bean tree.
Do you known how to solve this?
Thank you.
Regards.

I'm working with WebLogic Server 10.0 and the problem is if I restart the server this don't holds the lastest change that I made, it happens with any type of change (deploy, undeploy, create or delete servers/services, etc).
I've reviewed the log file and I've found the following error:
<Jun 2, 2008 6:45:14 PM CDT> <Warning> <Management> <BEA-141269> <The temporary bean tree updateDeploymentContext(Mon Jun 02 10:46:11 CDT 2008) was allocated for an undo, get, or activate operation, but has not been garbage collected.>
Stopping PointBase server...
PointBase server stopped.
Thank you for your attention

Similar Messages

Garbage collector does not work any way

when you unload some loaded swf file (Loaded with Loader
class) it's Event Listeners continue their jobs
is there anyway to solve this problem
for example please made three files
l1.fla , l2.fla , main.fla
in l1 creat a MovieClip with instance name "symbol_mc"
and type these code
this.addEventListener(Event.ENTER_FRAME,test1,false,0,true);
function test1(evt:Event){
trace("l1");
symbol_mc.addEventListener(Event.ENTER_FRAME,test2,false,0,true);
function test2(evt:Event){
trace("symbol");
in l2 only create a text to see if file is loaded
finally in main
create to buttons with instance names btn1_btn and btn2_btn
and add these codes
var lo:Loader;
var mc:MovieClip = new MovieClip();
this.addChild(mc);
function loadSomeFile(url:String) {
lo= new Loader();
this.addChild(lo);
lo.contentLoaderInfo.addEventListener(Event.COMPLETE,
movieLoaded);
lo.load(new URLRequest(url));
function movieLoaded(evt:Event) {
this.removeChild(mc);
mc = MovieClip(lo.content);
this.removeChild(lo);
this.addChild(mc);
lo=null;
btn1_btn.addEventListener(MouseEvent.CLICK,load1);
function load1(evt:MouseEvent) {
loadSomeFile("l1.swf");
btn2_btn.addEventListener(MouseEvent.CLICK,load2);
function load2(evt:MouseEvent) {
loadSomeFile("l2.swf");
create swf files l1 and l2 and then preview main
first try btn1_btn and then try btn2_btn you will see after
unloading l1 and loading l2 event listeners will continue their
jobs!!!!!!!
after loading l1 ev

did you checked what you write in adobe devnet?
you said i must null loader but i not only did it but also
unloaded that before but event continue his life
i think it is not error of loader class it is gc error for
another example of it's errors try this create 2 frame fla file
add one symbole in frame 2 and then add event listener to
enterframe event of symbol
with two button add navigation for going to frames one and
two
you will see each time you enter frame 2 another
eventlistener will add to symbol and for example if your listener
rotate symbol by one degree you will see each time speed will
increase because each of them rotate object 1 degree

Garbage Collection is Not working

I Installed J2dk1.4 in my System.it's garbage Collector is not working,It does'nt free the memory in case of Frames and Applets.I use many methods to explicitly free the memory, Like :
====================
System.exit(0);
System.gc();
====================
but it does'nt work can any body give me the solution?
Email : [email protected]

How are you determining that it doesn't free memory?
If you're expecting Task Manager to show the VM using less memory, that won't happen. GC frees memory internally, so it can use that memory for other objects. It doesn't return it to the OS.
Also, calling gc() will not necessarily force the GC to run. Unless you're using a profiler, or getting OutOfMemoryError, you can't say for certain that the VM is not releasing memory.
Also, even if it's not releasing it, it doesn't mean it's a problem. It's guaranteed to release it when it needs it, but it may or may not release it sooner.
Finally, System.exit may not do anything in an applet, for security reasons.
What is your actual problem?

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 and JPEG decoder

Hi,
I have a problem with the garbage collector decoding JPEG images received on a TCP socket. The process works but each time that I have to decode an image I have to create a new decoder, this causes that the garbage collector starts to work constantly looking for memory. When the gc starts to work the streamed images almost stop since the gc takes all the process.
Here is the code that has the problem. On this code you can see that I create a new ByteArrayInputStream and a MediaTracker, but I know how reuse this objets, the problem is on the decoder.
Does any one have an idea of how to solve it?
Thanks
public void cargarImagen(Visualizador vision,
                              Cabecera cabImg,
                              boolean completa,
                              boolean grabar,
                              boolean pantCIF,
                              JFrame1 jf1)throws Exception{
        Visualizador aux;
        ByteArrayInputStream byis = new ByteArrayInputStream(s1.buffer);
        try{
                decoder=JPEGCodec.createJPEGDecoder(byis);
                try{
                       // decode
                                               vision.image_Webcam=decoder.decodeAsBufferedImage();
                }catch(ImageFormatException b){
                  System.out.println("Incorrect image format");
                }catch(Exception a){
                  System.out.println("Incorrect image");
                mediaTracker_track = new MediaTracker(vision);
                mediaTracker_track.addImage(vision.image_Webcam, 0);
             mediaTracker_track.waitForID(0,500);
        }finally{
                  byis.close();
        if(mediaTracker_track.statusID(0, false) == MediaTracker.COMPLETE){
              vision.repaint();
         else{    /* incorrect image */
              vision.image_Webcam = null;
              System.out.println("Discarded image");
}

I think that this is not the case. Images come from a TCP connection and the application start to read the next image from the socket when the previous one has been decoded and painted.
So, images are not stored on memory and the received images rate depens on how fast is the application reading images from the socket.
However, it is a good idea to start gc before getting next image, the average rate will decrease but it will avoid the "jumps" on visualization.

What is the use of destroy() when there is an automatic garbage collector

what is the use of destroy() when there is an automatic garbage collector

what is the use of destroy() when there is an
automatic garbage collectorI don't recognize that particular method but some classes have a so called explicit termination method. Usually classes which allocate OS resources have such a method. It has to be called before the object is released for GC so the OS resourses can be returned properly.
Or do you mean finailize()? See "finalizers are not your friend" here,
http://www-128.ibm.com/developerworks/java/library/j-jtp01274.html

Can someone explain how garbage collector works in this program ?

class Chair {
static boolean gcrun = false;
static boolean f = false;
static int created = 0;
static int finalized = 0;
int i;
Chair() {
i = ++created;
if(created == 47)
System.out.println("Created 47");
public void finalize() {
if(!gcrun) {
// The first time finalize() is called:
gcrun = true;
System.out.println(
"Beginning to finalize after " +
created + " Chairs have been created");
if(i == 47) {
System.out.println(
"Finalizing Chair #47, " +
"Setting flag to stop Chair creation");
f = true;
finalized++;
if(finalized >= created)
System.out.println(
"All " + finalized + " finalized");
public class Garbage {
public static void main(String[] args) {
// As long as the flag hasn't been set,
// make Chairs and Strings:
while(!Chair.f) {
new Chair();
new String("To take up space");
System.out.println(
"After all Chairs have been created:\n" +
"total created = " + Chair.created +
", total finalized = " + Chair.finalized);
// Optional arguments force garbage
// collection & finalization:
if(args.length > 0) {
if(args[0].equals("gc") ||
args[0].equals("all")) {
System.out.println("gc():");
System.gc();
if(args[0].equals("finalize") ||
args[0].equals("all")) {
System.out.println("runFinalization():");
System.runFinalization();
System.out.println("bye!");
} ///:~
This code is From Bruce Eckel's "thinking in Java"
Here is what I understand and what I don't
At a certain point during the execution of the while loop (in the method main), the garbage collector kicks in and will call the method finalize() -
I am at a loss as to what happens afterwards -
Do the chairs continue to get created (which means the variable i keeps incrementing) and the finalize method keep getting called (which means finalized keeps incrementing) till the system realizes it is really low on memory and starts reclaiming memory ie i now starts decrementing ?
What I would like to know is the exact flow or execution of the code after the garbage collector starts kicking in ie. what happens to the variables "i" (does it increment and then decrement), "created" (does it keep incrementing ), "finalized" (does it keep incrementing) and when is the if i==47{ } statement within finalize() get executed.
There is no part of the code where i is being decremented (so I am guessing that it is the garbage collector reclaiming object memory that must be decrementing it).
I am really confused -unfortunately there's very little in the book that really explains the flow of execution after the garbage collector kicks in and finalize() is called.
Any help would be greatly appreciated

Nice example, but Bruce chose some suboptimal names, I think.
"i" can be thought of as the "ID" of a given Chair (note that it is not static). It is neither incremented nor decremented - it's just assigned from "created". This lets us identify specific chairs (like, say, "Chair #47").
"created" is a running total of the number of times the Chair constructor has been called.
"finalized" is a running total of the number of Chairs that have been finalized.
The process starts creating Chairs as fast as it can. Eventually, memory gets low, and gc() starts collecting Chairs. While that's happening, chairs are still being created in the main Thread. So "created" and "finalized" may both be incrementing at the same time.
When gc() picks Chair#47, the finalizer code sets a flag that causes new Chairs to stop being created. This causes the program to fall out of the while() loop, and the program spits out its data and exits.
On my machine, the program created 29,542 chairs before exiting.
Remember - often, gc() runs only when/if the JVM decides it's running low on memory. Specifics depend on the JVM and the startup options you use - some JVMs are very, very clever about doing incremental garbage-collection these days.
Does that make more sense?
Grant
(PS - it's very, very good that you posted a working code sample. But learn about the \[code\] and \[code\] tags, please - makes your sample WAY easier to read...)

* How about flash play 8 Garbage Collector working?

Hi, I need to add some Image controls dynamically, yes,the
number of those are unpredictable.
My code to create them like this:
quote:
public function addImg(name:String, x:Number, y:Number):void
var sm1:Image = new Image();
sm1.source = "imgs/down_medium.gif";
sm1.name = name;
sm1.x = x;
sm1.y = y;
this.addChild(sm1);
Then, it appeared in my application. if I add numbers of
Image in my stage, they eat my memory crazily.
so I want to kill some Image which is not in use, but I
crashed.
An Image named "img4kill" in stage, it's index in
this.getChildren() is4, and it holds a image which size is about
230K.
I tried to kill it like this:
quote:
this.removeChildAt(4);
yes, it's remove from the stage in faith, but I watched the
memory that the browser using, before and after killing it.
I found the memory it takes is not released.
How can I kill it from both the stage and memory ? I tried
the global function "delete" ,but failed too.
I know that flash play 8.5 and later use a powerfull
GC(garbage collector), but in the sample above, it dose't work for
me.
who can save me from this mud layer?any ideas?
thanks a lot .
(sorry about my ugly english)
[email protected]

Don't worry, the garbage collector will work very well in this case (and in every other case too :) ). It will only collect an object when no more references are pointing to it. Your array still holds a reference to all the items it contains (unless you explicitly do array[index] = null).
There are only three ways that I know of to destroy a reference to an Object: 1). Set the reference to null 2). Let the reference fall out of scope 3) reassign the reference to another object
The garbage collector will also be able to collect objects that have a cyclical references as long as none of the objects in the cycle are reachable.
It pays to understand the ins and outs of garbage collection and memory management in the VM. Knowing that will let you know, for example, that allocating an Object in Java is a very cheap operation (while it is pretty expensive in C/C++).
Check http://www.ibm.com/developerworks/java/library/j-jtp10283/ and http://www.ibm.com/developerworks/java/library/j-jtp11253/ and for more details about the GC
Also don't worry about the performance impact of setters and getters, either the javac compiler or the Virtual Machines Just In Time Compiler will inline those small methods.
In short don't worry about such low level performance problems and concentrate on your coding style and algorithms. The Hotspot JVM is an amazingly efficient piece of software. It also include a lot of optimizations that work very well in optimizing "standard" code. The more normally you code, the faster your program will be, so don't try clever optimizations tricks, they probably won't work well in java.
Read the following articles for some discussion about performance in Java:
http://www.ibm.com/developerworks/java/library/j-jtp04223.html
http://www.ibm.com/developerworks/java/library/j-jtp09275.html
http://www.ibm.com/developerworks/java/library/j-jtp01274.html

How to get the garbage collector to work?

Hi,
i have i program where i load an image scale it down and save the scaled version in an array. I do this for a whole directory of images.
After every image i set the temporary variable for the loaded image = null and call the function System.gc().
My problem is, that the garbage collector does�nt give the memory of the loaded image free and the used memory of my program grows with every loaded image.
/* Reads all images from a folder an stores them in an Array of images */
     public static BufferedImage[] readScaledImagesFromFolder(String folder,
               int maxSize) {
          File dir = new File(folder);     /* Open the Folder */
          String[] children = dir.list();          /* Get the children of the folder */
          if (children == null) {
             // Either dir does not exist or is not a directory
              System.out.println("No images in the folder!");
              return null;
         } else {
              /* Init array for images */
              BufferedImage[] images = new BufferedImage[children.length];
              int i = 0;
              int index = 0;
              BufferedImage temp;
              String filename, fileending;
             for (i=0; i<children.length; i++) {
                  // Get filename of file or directory
                 filename = children;
     /* Get the fileending of the file */
     fileending = filename.toLowerCase().substring(filename.length()-4);
     if(fileending.equals(".jpg") || fileending.equals(".bmp")
               || fileending.equals(".png") || fileending.equals(".gif"))
          /* Read the image */
          temp = util.ImageUtils.loadBufferedImage(folder+"/"+filename);
          /* Scale the image down and save it in an array */
          images[index] = Util.getScaledImage(temp,maxSize);
          index++;
     temp = null;
     System.gc();
     Mosaic.sourceImageNum = index;
     System.out.println((index+1)+" resized pictures loaded from folder: "+folder);
     return images;
How can i get the gargabe collector to work after every iteration?
I tried to let the Thread.sleep(10) after System.gc() but it does�nt help.
Thank you every much
JackNeil

Hm yes.. i now that System.gc() is only a
suggestion.
But i know what my program is doing and that it
does�nt need the temporary image anymore after i have
a scaled down version. And the temporay image will become unreachable as soon as reading the next one overwrites your temp variable. Setting the variable to null doesn't have much effect.
It would be smarter to load the new image over the
old temporary image and not to expand the heapsize to
maximum.Then look at the possibitly of loading the next image into the same bufferedimage.

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

Stateless ejb staying live after a garbage collector

Hi,
I use an aplication based in struts, in the actions i call session that call cmps, both ejb are stateless.
Every thing works fine until i make some stress test, when i find that the server (Websphere) stay out of memory. After this i found that my sessions and cmps are staying live after the garbage collector run and i don't know why because the thread already finish and the ejb are stateless.
Anyone already have this problem, how can i clear the memory of this objects?
Thanks in advanced
Ricardo

Adjust the size of your EJB pool. Just because your application is no longer using the objects doesn't mean that the container won't hang on to them for re-use (object creation is an "expensive" operation).

Problem with garbage collector -

I'm experiencing a problem with the Java Garbage Collector.
It simply doesn't work when I try to free the memory that is used
by an object in my program...
I explicitly declared this object as null, and called System.gc, but it seems it isn't working.
What might be the reason?
This object uses a lot of memory. Therefore, I MUST destroy it after it's no longer
needed.

Ok. I'll try to be more specific...
My "situation" seems something like that
class Program {
Xclass class1;
void method1() {
class1 = new Xclass();
} (End of class Program)
class Xclass {
Yclass class2;
Public Xclass( ) {
class2 = new Yclass();
add(class2);
} (end of class Xclass)
class Yclass {
Public Yclass(Container parent) {
(no explicit reference to Xclass or Program classes or any variable or instantiations of said classes);
} (end of class Yclass)
Well, I know that the gc is not being done because the first time I call method1 everything goes fine. But When I try it again an OutOfMemoryError happens...
I tried to do the following (I know, it's not elegant, but I just wanted to get some results):
void method1() {
class1 = null;
System.gc();
class1 = new Xclass();
Again it worked in the first time. But later...

Garbage collector - controlling it

The main performance problem on our website right now is from the garbage collector. Yes, our site is very 'thick', but the gc locks out other threads for 10 seconds or so regularly, and once a day or locks it up for several MINUTES. The main problem is that we have a few very large objects that never go away, but the gc still has to occasionally scan them.
I developed a way to put the two GarbageCollector threads (per vm) into the lowest priority. I've seen documentation that this is where they are supposed to be anyway, but they are really at the normal level with everything else. This works great on NT, but only works ok on Solaris. On NT, the gc still pegs the cpu, but other threads are almost unnaffected.
Anyway, my bosses are concerned about this fix, wondering what negative impact it will have or if the gc won't get enough time or whatever.
I just wondered what you all think of this fix. Has anyone else tried it?
Also, does anyone know of a way to tell the gc not to every scan certain objects?

You can also try the incremental and concurrent garbage collectors. These are enabled with the -Xincgc and -Xconcgc options to the java command, respectively. They may have lower performance overall, but generally have much shorter GC pause times.
Of course, don't forget the top tip for improving GC performance is always not to create unnecessary objects!

Force Garbage Collector calling

Hello
I have simple, static, single thread program. But it's a lot of memory demanding (large SortedSet, about one million items). After I finish working with this big SortedSet, I call "clear()" on it, for safe. Function uses this Set exits, and reference to this Set dies. Problem is, when this function exits, it's called multiple times again (same function), but unreferenced memory is still occupied, and heap usage grows and grows.
I need to force calling Garbage Collector and HALT MAIN PROCESS until GC refreshes all of unref. memory.
I tried calling "System.gc()" - without effect, parameter "-Xincgc" - without effect.
Thank you very much for help.
Pleas excuse my poor English, but I hope you understand me.
Tony (Czech Republic)

Why is this growing heap a problem, and why do you feel compelled to force gc?
Virtually all non-trivial applications experience growing and growing heap usage.
But the JVM should run gc when it is running out of memory anyway.
Did you get an OutOfMemoryError?
If you did, then you should review either your JVM heap settings, or in the worst case, your code. Your program may unintentionnally hold on to objects after being done with them (a java 'memory leak').
If you didn't get an OutOfMemoryError, then I suggest you don't worry about it.

Will Garbage Collector collect this?

If an object is not referenced by any other object, however, it holds a reference to itself, will the garbage collector remove it?
If it works optimally it must remove it, but I don't know how exactly it works.
Regards,
Ahmed Saad

Google is your friend.
http://www.javaworld.com/javaworld/jw-08-1996/jw-08-gc.html
http://www.javacoffeebreak.com/articles/thinkinginjava/abitaboutgarbagecollection.html

Garbage collector don't works.

Similar Messages

Maybe you are looking for