List of categories and situations of memory leaks

Memory leaks are generally divided into several situations

Common memory leaks are caused by multiple executions of code. A memory leak occurs every time it is executed.

2. Sporadic memory leaks refer to code where memory leaks occur only under certain specific environments or operations. This kind of memory leak does not happen continuously, but occasionally. However, it is important to note that sporadic memory leaks may become frequent under certain circumstances. Therefore, the testing environment and testing methods are very important factors when detecting memory leaks.

One-time memory leak means that the code where the memory leak occurs will only be executed once, or due to algorithm flaws, there will always be one and only one piece of memory leaked. For example, memory is allocated in the constructor of a class, but the memory is not released in the destructor. Since only one instance of this class exists, the memory leak will only occur once. In this case, the memory leak will not reoccur, but it will still cause a waste of memory resources and degrade system performance. Therefore, when writing code, we should pay special attention to avoid one-time memory leaks.

4. Implicit memory leaks refer to memory that is frequently allocated while the program is running, but is not released until the end of the program. Strictly speaking, this is not a real memory leak, because the memory will eventually be released. However, for long-running server programs, if the memory is not released in time, the system may eventually run out of memory. Therefore, we call this situation an implicit memory leak. This memory leak does not cause an immediate problem, but over time, it may have a negative impact on system performance and stability. In order to avoid implicit memory leaks, developers should release unused memory in a timely manner to ensure the normal operation of the system.

Under what circumstances will memory leak occur in java

Memory leak refers to objects or variables that are not used by the program occupying memory for a long time. In Java, there are several situations of memory leaks.

Long-lived objects holding references to short-lived objects may cause memory leaks. For example, in a cache system, we load an object into the cache and put it in the global map object, but then the object is no longer used. However, the object is still referenced by the cache and cannot be released. In this case, objects that are no longer used should be cleaned up in time to avoid memory leaks.

For global collection variables, if there is no corresponding deletion mechanism, the memory usage may only increase rather than decrease. Therefore, it is necessary to provide a deletion mechanism or a regular cleanup strategy.

Incorrect use of singleton mode is a common memory leak problem. Once the singleton object is initialized, it will exist (in the form of static variables) throughout the JVM life cycle. If the singleton object holds a reference to an external object, the external object will not be recycled normally by the JVM, resulting in a memory leak.

The difference between memory overflow and memory leak, causes and solutions

Memory overflow (out of memory) means that when a program applies for memory, an error occurs due to insufficient available memory space and cannot meet the needs of the program. For example, if the program applies for an integer type memory space, but actually needs to store a value that can be accommodated by a long integer, a memory overflow error will occur. In this case, the program cannot run normally, and the problem needs to be solved by increasing available memory or optimizing program logic.

Memory leak means that the program cannot release the allocated memory space after applying for memory. The harm of a memory leak can be ignored, but the consequences of accumulation of memory leaks are serious. No matter how much memory is, it will be occupied sooner or later.

Memory leak will eventually lead to out of memory!

Causes:

1. The amount of data loaded in the memory is too large, such as retrieving too much data from the database at one time;

2. There is a reference to the object in the collection class, which is not cleared after use, making the JVM unable to recycle;

3. There is an infinite loop in the code or the loop generates too many duplicate object entities;

4. BUG in the third-party software used;

5. The startup parameter memory value is set too small

solution:

1) When processing data transmission of some IO streams, try to turn off the IO stream at the end

2) When processing downloaded photos, use BitmapFactory.options. Set the insameplesize() method to compress images to reduce resource usage; a special topic will be written below on image compression issues;

3) You can also reduce the memory occupied by reducing the pixels of the photo

4) Resource recycling: Bitmap.recycle()bitmap=null;

5) Try to use global variables and avoid new objects

Memory leaks themselves will not cause any harm. As an ordinary user, they will not feel the existence of memory leaks at all. What's really harmful is the accumulation of memory leaks, which will eventually consume all the system's memory. From this perspective, a one-time memory leak is not harmful because it does not accumulate, while an implicit memory leak is very harmful. Cause the program to crash;

How to solve the problem of internal memory leakage

meeting. The reason why Java causes memory leaks is very clear: if a long-lived object holds a reference to a short-lived object, a memory leak is likely to occur. Although the short-lived object is no longer needed, because the long-lived object holds its reference As a result, it cannot be recycled. This is the scenario where memory leaks occur in Java.

1. Collection class, the collection class only has methods to add elements, but does not have a corresponding deletion mechanism, causing memory to be occupied. This is actually not clear. If this collection class is just a local variable, it will not cause a memory leak at all. After the method stack exits, there will be no references and it will be recycled normally by the jvm. And if this collection class is a global variable (such as static attributes in the class, global map, etc., which have static references or final always pointing to it), then there is no corresponding deletion mechanism, which is likely to cause the memory occupied by the collection to be only It increases rather than decreases, so it is necessary to provide such a deletion mechanism or a regular cleanup strategy.

2. 2. Singleton mode. Improper use of the singleton pattern is a common problem that causes memory leaks. After being initialized, the singleton object will exist throughout the life cycle of the JVM (in the form of static variables). If the singleton object holds a reference to an external object, Then this external object will not be recycled normally by the jvm, causing a memory leak. Consider the following example: class A{

3. public A(){

4. B.getInstance().setA(this);}

5. ....}

6. //Class B adopts singleton mode class B{

7. private A a;

8. private static B instance=new B();

9. public B(){}

10. public static B getInstance(){

11. return instance;}

The above is the detailed content of List of categories and situations of memory leaks. For more information, please follow other related articles on the PHP Chinese website!