garbage collection introduction what is garbage and how can we deal with it? garbage collection...
TRANSCRIPT
Garbage Collection
Introduction
What is garbage and how can we deal with it?
Garbage collection schemes
Reference Counting
Mark and Sweep
Stop and Copy
A comparison
How Objects are Created in Java
An object is created in Java by invoking the new() operator.
Calling the new() operator, the JVM will do the following:
allocate memory;
assign fields their default values;
run the constructor;
a reference is returned.
How Java Objects Memory Reclaimed
Java does not provide the programmer any means to destroy objects explicitly
The advantages are
No dangling reference problem in Java
Easier programming
No memory leak problem
What is Garbage?
Garbage: unreferenced objects
Student ali= new Student();
Student khalid= new Student();
ali=khalid;
Now Ali Object becomes a garbage,
It is unreferenced Object
Ali Object
ail
khalid
Khalid Object
What is Garbage Collection?
Finding garbage and reclaiming memory allocated to it.
When is the Garbage Collection process invoked?
When the total memory allocated to a Java program exceeds some threshold.
Is a running program affected by garbage collection?
Yes, the program suspends during garbage collection.
Refference to ali object
Refference to khalid object
Khalid Object
Reduce, Reuse, Recycle
Modern Societies produce an excessive amount of waste?
What is the solution?
Reduce
Reuse
Recycle
The same Applies to Java!!!
Reduce Garbage
A Java program that does not create any objects does not create garbage.
Objects used until the end of the program do not become garbage.
Reducing the number of objects that may be used until the end of the program will reduce the amount of garbage generated.
Reuse GarbageReuse objects instead of generating new ones.
for (int i=0;i<1000000; ++i) { SomeClass obj= new SomeClass(i); System.out.println(obj);
This program generates one million objects and prints them out.
SomeClass obj= new SomeClass();for (int i=0;i< 1000000; ++i) { obj.setInt(i); System.out.println(onj);
Using only one object and implementing the setInt() method, we dramatically reduce the garbage generated.
Recycle Garbage
Don't leave unused objects for the garbage collector.
Put them instead in a container to be searched when an object is needed.
Advantage: reduces garbage generation.
Disadvantage: puts more overhead on the programmer.
Helping the Garbage Collector
Sometimes we need the garbage collector to run more frequently.
How we can help the collector?
Eliminate all references to objects that are no longer needed
This can be done by assigning null to every variable that refers to an object that is no longer needed
Reference Counting Garbage Collection
Main Idea: Add a reference count field for every object.
This Field is updated when the number of references to an object changes.
ExampleObject p= new Integer(57);Object q = p;
57
refCount = 2
p
q
Reference Counting (cont'd)The update of reference field when we have a reference
assignment ( i.e p=q) can be impelmented as follows
if (p!=q){ if (p!=null) --p.refCount; p=q; if (p!=null) ++p.refCount;}
Object p = new Integer(57);
Object q= new Integer(99);
p=q;
57
refCount = 0
p
q
99
refCount = 2
Reference Counting (cont'd)
Advantages and Disadvantages
+ Garbage is easily identified.
+ Garbage can be collected incrementally.
- Every object should have a reference count field.
- Overhead for updating reference count fields.
Reference Counting (cont'd)
What in case of indirect references?
We can still use reference counting, provided we consider all references to an object including references from other objects.
Object p = new Association(new Integer(57), new Integer(99));
Reference Counting (cont'd)
When does reference counting fail?
When head is assigned to null, first object reference count becomes 1 and not zero
Reference counting will fail whenever the data structure contains a cycle of references
next
refCount = 1
ListElements
refCount = 1
ListElements
next
refCount = 1
ListElements
next
head
Mark-and-Sweep Garbage Collection
It is the first garbage collection algorithm that is able to reclaim cyclic data structures.
Mark and sweep algorithm consists of two phases:
mark phase
sweep phase
for each root variable r mark(r); sweep();
Mark and Sweep (cont'd)void sweep(){ for each Object p in the heap { if (p.marked) p.marked=false; else heap.release(p);
}}
program
Mark and Sweep (cont'd)
Advantages
It correctly identifies and collects garbage even in the presence of reference cycles.
No overhead in manipulating references.
Disadvantages
The program suspends while garbage collecting.
Fragmentation problem.
Stop-and-Copy Garbage Collection
This algorithm collects garbage and defragments the heap.
The heap is divided into two regions: active and inactive.
When the memory in the active region is exhausted, the program is suspended and :
Live objects are copied to the inactive region contiguously
The active and inactive regions reverse their roles
The Algorithm
for each root variable r r=copy(r,inactiveHeap);swap (activeHeap,inactiveHeap);
Stop-and-Copy Garbage Collection (cont'd)Object copy(Object p, Heap destination) { if (p==null) return null; if (p.forward==null) {
q=destination.newInstance(p.class); p.forward= q; for each field f in p { if ( f is primitive type) q.f=p.f; else q.f= copy(p.f,
destination); }q.forware = null;
}return p.forware;
}
A’
null
B’
null
C’
null
headinactive
active
Stop-and-Copy Garbage Collection (cont'd)
Advantages
Defragments the heap.
Disadvantages
All objects should be copied when the garbage collector is invoked.
It requires twice as much memory as the program actually uses.