garbage-collection

问题 Can anyone pls tell me that how to use lua_pop() function correctly in C++. Should I call it when I use a lua_get*() function ? like. lua_getglobal(L, "something"); lua_pop(L, 1); or how to use it ? Will the garbage collector clear those stuff after the threshold ? Thanks. 回答1: You call lua_pop() to remove items from the Lua stack. For simple functions, this can be entirely unnecessary since the core will clean up the stack as part of handling the return values. For more complex functions,

问题 I've often read that in the Sun JVM short-lived objects ("relatively new objects") can be garbage collected more efficiently than long-lived objects ("relatively old objects") Why is that so? Is that specific to the Sun JVM or does this result from a general garbage collection principle? 回答1: Most Java apps create Java objects and then discard them rather quickly eg. you create some objects in a method then once you exit the method all the object dies. Most apps behave this way and most

问题 we just had a meeting to address some performance issues in a web application that is used to calculate insurance rates. The calculations are implemented in a C/C++-module, that is used in other software packages as well. To make it available as a webservice, a Java wrapper was implemented that exposes an XML based interface and calls the C/C++-module via JNI. Measurements showed that several seconds were spent on each calculation inside the Java part. So my first recomodation was to enable

问题 I look after a WPF desktop app which many users run on varying hardware. Multiple threads constantly churn through a large volume of data. Turning on .NET Framework 4.5 Background server garbage collection has shown significant performance improvements, however this comes at the cost of more memory being used and different CPU usage patterns. This is a potential problem for users with less-powerful machines, so I want to give the users who'd benefit most an opt-in to having server GC enabled

问题 I look after a WPF desktop app which many users run on varying hardware. Multiple threads constantly churn through a large volume of data. Turning on .NET Framework 4.5 Background server garbage collection has shown significant performance improvements, however this comes at the cost of more memory being used and different CPU usage patterns. This is a potential problem for users with less-powerful machines, so I want to give the users who'd benefit most an opt-in to having server GC enabled

问题 I'm trying to understand how the GC acts when an object is not being used anymore, my test is to do nothing with the object (after used) but it didn't work, the object's destructor was never called. I've created an example program trying to wait until the object is destroyed, but after 4 hours running nothing happens. Note: I know if I set the object to null the GC will collect it, but I just want to see the "normal" way the GC itself collects the object. using System; using System

问题 I'm trying to understand how ZGC works in detail. Let's consider a simple Java example: var v = new Object[]{ new Object() }; Let's call a : the array object o : the object referenced by v[0] r : the reference to a s : the reference to o The image below shows the artefacts graphically: Let's assume that the first gc cycle starts and a , o are relocated. Let's further assume that the app doesn't access the objects. gc cycle 1: a) Marking phase: at the end of the marking phase the marked0 bit

问题 I'm trying to understand how ZGC works in detail. Let's consider a simple Java example: var v = new Object[]{ new Object() }; Let's call a : the array object o : the object referenced by v[0] r : the reference to a s : the reference to o The image below shows the artefacts graphically: Let's assume that the first gc cycle starts and a , o are relocated. Let's further assume that the app doesn't access the objects. gc cycle 1: a) Marking phase: at the end of the marking phase the marked0 bit

问题 I'm trying to understand how ZGC works in detail. Let's consider a simple Java example: var v = new Object[]{ new Object() }; Let's call a : the array object o : the object referenced by v[0] r : the reference to a s : the reference to o The image below shows the artefacts graphically: Let's assume that the first gc cycle starts and a , o are relocated. Let's further assume that the app doesn't access the objects. gc cycle 1: a) Marking phase: at the end of the marking phase the marked0 bit

问题 I have a 64-bit .NET process that runs for days. The process consumes a native 32-bit COM server using DCOM. Once in a while the COM server runs out of memory because the .NET process garbage collector only sees the RCWs of the COM objects and those are quite lightweight and "not worth collecting". I need to somehow make garbage collector aware of those COM objects. For the record, I tried to run the same code periodically force-starting garbage collection and the problem goes away so the