Does garbage collection guarantee that a program will not run out of memory?

I he开发者_运维知识库ard most elegant property of java is Garbage Collection I wanna know does it guarantee that a program will not run out of memory?

No, it's always possible that you'll try to allocate more memory than is available.

Automatic garbage collection only means that garbage (i.e., unreferenced memory) is automatically collected (i.e., reclaimed for further use). If you keep references to it, it's not garbage, and not collected.

No it does not guarantee this. It is perfectly possible for a programmer to mistakingly create objects which never go out of scope, thus consuming more and more memory until all heap is exhausted.

It is the programmer's responsibility to ensure that objects no longer in use are no longer referenced by the application. That way the garbage collector can do its job and reclaim memory used by these objects.

Example

public class Main {
  public static void main(String[] main) {
    List<String> l = new LinkedList<String>();

    // Enter infinite loop which will add a String to
    // the list: l on each iteration.
    do {
      l.add(new String("Hello, World"));
    } while(true);
  }
}

No, there are still many ways to run out of memory. The garbage collector can only reclaim memory for objects that are no longer referenced - it is up to you to make sure that you are not referencing objects you don't need, or to use Soft References for objects you would like to have, but don't mind disappearing if memory gets tight.

To answer your question, NO. Garbage collection does not guarantee that a program will not run out of memory.

• Consider object you don't want to use any more are like garbage.
• References to those objects will be like having that garbage in your house.
• Garbage collection is like your town's garbage truck that collects garbage.
• If you won't release those references, it is like not taking garbage out and soon your house will be over filled with garbage as garbage truck guys won't take out garbage from your house.

Unreferenced objects will be garbage collected automatically by garbage collector. In java, most references to objects are released automatically once you come out of method.

Objects have reference to other objects, which in turn referr to other objects creating whole object graph. So as such object can be referenced by more than one object.

• If object is having zero references, it is eligible for garbage collection.
• Objects are allocated on heap.
• Garbage collector runs from time to time to delete unreferenced objects from heap.
• If you keep creating more objects on heap without releasing you will eventually get OutOfMemoryError

Example with garbage collection at work

public class TestGarbageNoError {

 public static void main(String[] args) {
  String hugeString;
  for (int i = 0; i < Integer.MAX_VALUE; i++) {
   System.out.println("i = " + i);
   hugeString = getHugeString();
   // At each iteration reference variable hugeString 
   // points to new String object. Hence there will be 
   // zero reference to previous string object and will
   // eventually be garbage collected
  }
 }

 public static String getHugeString() {
  StringBuilder sb = new StringBuilder();
  for (int x = 0; x < 5000000; x++) {
   sb.append(x);
  }
  return sb.toString();
 }
}

.

Example with memory leak at work

public class TestGarbageError {

 public static void main(String[] args) {
  Collection<String> memoryLeak = new ArrayList<String>();
  for (int i = 0; i < Integer.MAX_VALUE; i++) {
   System.out.println("i = " + i);
   String hugeString = getHugeString();
   memoryLeak.add(hugeString);
   // At each iteration reference variable hugeString 
   // points to new String object. But all objects are added 
   // to memoryLeak Collection and will always have atleast one 
   // reference, i.e. from memoryLeak object. Hence this string
   // objects will never be garbage collected and program will
   // eventually run out of memory
  }
 }

 public static String getHugeString() {
  StringBuilder sb = new StringBuilder();
  for (int x = 0; x < 5000000; x++) {
   sb.append(x);
  }
  return sb.toString();
 }
}

No. If you construct a lot of objects (millions) and keep a reference to them so they don't go out of scope (for example by adding them to an ArrayList), you could run out of addressable memory.

Absolutely not. Even in a garbage collected language like Java you can easily lose references, meaning objects will never get garbage collected.

Even then, you may simply instantiate (and keep reference to) too many objects for the system to handle.

How could anything ensure a program doesn't run out of memory short of arbitrarily deleting an item from memory to make room for new allocations?

Now, what if you are actually keeping a reference on (using) the thing randomly chosen to be evicted? You will soon have incorrect behavior.

No. The garbage collector, helps you to free unused memory automatically.

The way it works is, if an object reference can't be reached, the memory for that object may be garbage collected.

For instance:

public void test() {
     Object o = new Object();
     // the memory used by  o may be garbage collected after this line
}

But if you never release object references, the garbage collector will never collect anything and a OutOfMemoryError will be thrown.

List list = ....
public void test() {
     o = new Object();
     list.add( o ); 
     // the memory used by  o WON'T be garbage collected after this line
     // because its reference is used in the list.
}

If you use this several times:

 while( true ) {
     test();
 }

The list will keep growing indefinitely until you run out of memory

No. Garbage collection only protects against one kind of memory leak. Specifically, the kind that occurs if you don't explicitly free up memory when your application no longer needs it. If your application holds references to unneeded objects (eg. evergrowing Lists), the garbage collector cannot clean them up and your application can still run out of memory.

No, not at all.

In languages without garbage collection, the programmer (or a library he uses) is responsible for making requests for memory and for returning the allocated memory for "recycling". there are no guarantees that the memory would be available when it is requested. However, if you never explicitly "recycle", there could be a situation where a request is rejected because no memory is available, but that if the memory was recycled that block could have been returned for this request.

Having automated garbage collection means that the system may recycle for you. As a result, certain requests would be filled using "recycled" memory. However, as with non-GC languages, some requests cannot be filled.

For instance, if your system has 1000 blocks available and you need 1500 at the same time, no GC in the world is going to help you because nothing is really available for recycling.

No, garbage collection cannot guarantee that your application will not run out of memory. It will not even guarantee that your application will not run out of memory when memory is available. If you come close to running out of memory or are allocating many object it can cause GC to thrash, throwing an out of memory exception. The program can also run out of memory when it has used all the physical memory (actual and virtual) or the program exceeds the maximum memory allowed by the JVM (see -Xmx).

However, it is guaranteed that before the JVM declares OutofMemoryException it will garbage collect all collectible references and consider to use the now free memory.