Memory disclosure
Many people are talking about memory leaks. Of course, for C / C , this should be old-fashioned, but many Java people have more and more to discuss this problem, I write a summary here, I hope to have a certain reference to everyone. value.
I must understand first.
1.c / c is the programmer management memory, and Java memory is automatically recovered by GC.
Although I am not very familiar with C , this should have no common sense mistake.
2. What is memory leak?
Memory leaks refer to memory that cannot be recycled in the system, sometimes causing insufficient memory or system crash.
The case where memory is not released in C / C is memory leak.
3. Java exists in memory leaks
We must first recognize this before it can be discussed. Although Java has memory leaks, it is basically not very concerned about it, especially those who don't pay attention to the code itself, don't pay attention to this.
The memory leak in Java is of course referring to: an object that is useless but the garbage collector cannot be recycled.
And even if there is a memory leak problem, it is not necessarily shown.
4. Java in parameters are transmitted.
For basic types, everyone is basically no objection, but we can't have objections for reference types.
Java memory leak
The JVM recycling algorithm is very complicated. I don't know how they implement it, but I only know what they have to achieve is: For objects that are not referenced, it can be recycled.
So you have to cause memory leaks to do:
Hold a reference to the useless object!
Don't think that this is easy, since it is useless, how can you hold it?
Since you still hold it, how can it be useless?
I really can't think of more classic examples than that stack, so that I also want to quote the examples of others.
The following example is not what I think, it is the book, of course, if you don't see it on the book, it may be
I thought about it in a period of time, but I said that I didn't believe in myself.
Public class stack {
Private Object [] Elements = New Object [10];
Private int size = 0;
Public void push (Object E) {
EnsureCapacity ();
Elements [Size ] = E;
}
Public Object Pop () {
IF (size == 0)
Throw new emptystackexception ();
Return Elements [- size];
}
PRIVATE VOID ENSURECAPACITY () {
IF (Elements.Length == size) {
Object [] OLDELEMENTS = Elements;
Elements = New Object [2 * Elements.Length 1];
System.Arraycopy (Oldelements, 0, Elements, 0, size);
}
}
}
The above principle should be very simple, if the stack adds 10 elements, then all bomb it, although the stack
It is empty, there is no thing we want, but this is an object that cannot be recycled, this is in line with memory
Two conditions for leaks: useless, unable to recover.
However, there is such a thing that does not necessarily lead to what kind of consequences, if this stack is less,
Just wast a few K memory, anyway, our memory is g., There is any influence, then say
This thing will soon be recovered, what is the relationship. Look at two examples below.
Example 1
Public class bad {public static stack s = stack ();
STATIC {
S.push (new object ());
S.POP (); // This has an object in memory disclosure
S.push (new object ()); // The object above can be recovered, is equal to it.
}
}
Because it is Static, it has always been to the program exit, but we can also see it has its own function.
That is to say, if your Stack has up to 100 objects, then only 100 objects cannot be recycled.
In fact, this should be very easy to understand, and there is 100 references within Stack. The worst case is that they are
Useless, because we resemble new progress, the previous reference naturally disappears!
Example 2
Public class nottoobad {
Public void dosomething () {
Stack s = new stack ();
S.push (new object ());
// Other code
S.POP (); // This also causes objects that cannot be recycled, and memory leaks.
} // Exit method, S is automatically invalid, S can be recovered, the reference within STACK is naturally gone, so
// This can also be self-healing, and it can be said that this method does not have memory leaks, but it is a little late.
// Give GC, because it is closed, not open, can be said that the above code is 99.9999%
// The situation will not cause any influence, of course, you don't have any bad influence, but
// Can definitely be a garbage code! There is no contradiction, I will not have an empty for loop in it.
/ / What is much about, will you do this?
}
The above two examples are just small, but the memory leaks in C / C are not Bad, but Worst.
If they have no recycling, they will never be recycled, and frequent calls this method is not used!
Because Java also has self-healing features (my own name, I haven't applied for patents), so Java's memory leak issues
Almost negligible, but people know that people don't make it.
I don't know anyone! Java has memory leaks, but don't exaggerate their words.
If you are not very familiar with Java, you don't have to care about this, I said that you accidentally write memory leaks, just like you have a small probability, joking, it should be small. many!
And even if you have a fortunate to write this code, winning! Basically, it is a pack of washing powder, and it will not make you rich, and there is no big impact on the system.
Worry
No words can be said
Object obj = new object ();
Obj = null; // This completely, because withdrawn scope, the reference is automatically disappeared
/ / Don't have such a statement in your program, not wrong, but it is not anger
2. Thinking that it is not true
Void func (Object O) {
o = new Object ();
Return
}
When we know that the Java parameter is a pass value, you know what the above method is not wrong, it is an object to be applied and then throwing it to the GC. Because it is a pass value, here is a copy of a call, will it be unable to recover?
Isn't it a copy, how to exit the method, how can this object stay?
3. Try to avoid
Class a {
B b = new b (this);
}
Class b {
A a a;
B (a) {this.a = a;
}
This existence is cited to each other, which may result in the phenomenon of the island, but this will not cause memory disclosure.
However, I think this will reduce the efficiency of GC, just come from my intelligence, I think this situation is more general.
The situation is difficult to judge how to recycle! Of course, GC is smart than me, but you should also move a little brain.
