Introduction

A memory leak is a memory management problem where a program keeps using memory that is no longer needed.

In simple words, a memory leak happens when memory is allocated but not properly released or cleaned up after use.

Memory leaks are dangerous because they may not cause an immediate error. Instead, they slowly consume memory over time. This can make a program slow, unstable, or eventually crash.

Easy Real-Life Example

Classroom Example:
Chair reserved
Student uses chair
Student leaves
Reserved sign is not removed
Chair cannot be reused

Programming Example:
Memory allocated
Program uses memory
Program no longer needs memory
Memory is not released
Memory cannot be reused

This is similar to a memory leak. Memory is no longer useful, but it remains occupied.

What is a Memory Leak?

A memory leak occurs when a program keeps memory allocated even though that memory is no longer needed.

This memory becomes unavailable for other parts of the program. If this continues repeatedly, the program may use more and more memory.

Memory leak lifecycle:

1. Program requests memory.
2. Program uses memory.
3. Program no longer needs memory.
4. Program forgets to release memory.
5. Memory remains occupied unnecessarily.

Memory Leak and Heap Memory

Memory leaks are commonly related to heap memory, because heap memory is used for dynamic allocation such as objects, arrays, lists, and data structures created during program execution.

Stack memory is usually released automatically when a function ends, but heap memory may require manual release or garbage collection depending on the programming language.

Simple Memory Leak Example

The following pseudocode shows a basic memory leak idea.

/*
Memory leak example.
Memory is allocated but never released.
*/

ENTRY POINT
    data = ALLOCATE memory for 100 numbers

    STORE values in data
    DISPLAY data

    /*
    Memory should be released here,
    but the program forgets to release it.
    */

END ENTRY POINT

In this example, memory was allocated but not released after use. If this happens many times, memory usage keeps increasing.

Corrected Version

/*
Correct memory management.
Memory is released after use.
*/

ENTRY POINT
    data = ALLOCATE memory for 100 numbers

    STORE values in data
    DISPLAY data

    FREE data
    SET data = null
END ENTRY POINT

Here, memory is properly released after use, so it can be reused later.

Why Memory Leaks Are Dangerous

Memory leaks are dangerous because they usually grow slowly. A program may work correctly at first, but after running for a long time, it may become slow or crash.

Why Memory Leaks Are Hard to Notice

Memory leaks may not be visible immediately. A small leak may not affect a short-running program, but it can cause serious problems in a long-running program.

Small leak:
1 KB memory leaked per operation

If operation runs:
10 times    → 10 KB leaked
1,000 times → 1,000 KB leaked
1,000,000 times → huge memory waste

This is why memory leaks are especially harmful in applications that run continuously.

Where Memory Leaks Matter Most

Common Causes of Memory Leaks

Memory leaks can happen in different ways depending on the programming language and memory management model.

Cause 1: Forgetting to Release Memory

/*
Wrong: Memory allocated but not released.
*/

FUNCTION processData()
    buffer = ALLOCATE memory

    USE buffer

    /*
    Missing:
    FREE buffer
    */
END FUNCTION

If processData() runs many times, each call may leak memory.

Better Version

FUNCTION processData()
    buffer = ALLOCATE memory

    USE buffer

    FREE buffer
    SET buffer = null
END FUNCTION

Cause 2: Losing the Pointer

If a program overwrites a pointer before freeing the memory it points to, the old memory may become unreachable and cannot be released manually.

/*
Wrong: Old memory address is lost.
*/

ptr = ALLOCATE memory for Block A

ptr = ALLOCATE memory for Block B

/*
Block A is still allocated,
but the program lost its pointer.
This causes a memory leak.
*/

Better Version

ptr = ALLOCATE memory for Block A

FREE ptr

ptr = ALLOCATE memory for Block B

FREE ptr
SET ptr = null

Cause 3: Early Return Before Cleanup

/*
Wrong: Function exits before memory is released.
*/

FUNCTION readData()
    data = ALLOCATE memory

    IF error occurs THEN
        RETURN
    END IF

    USE data

    FREE data
END FUNCTION

If an error occurs, the function returns before FREE data is executed.

Better Version

FUNCTION readData()
    data = ALLOCATE memory

    IF error occurs THEN
        FREE data
        RETURN
    END IF

    USE data

    FREE data
END FUNCTION

Memory Leaks in Garbage-Collected Languages

Garbage collection helps clean unreachable objects, but memory leaks can still happen if objects remain reachable unnecessarily.

In a garbage-collected language, the memory leak often happens because the program still holds a reference to an object that is no longer logically needed.

cache = []

FOR EACH request
    data = CREATE large object
    ADD data TO cache

/*
If old data is never removed from cache,
the cache keeps growing.
Garbage collector cannot clean it
because it is still reachable.
*/

Unbounded Cache Leak

A cache stores data for reuse. But if a cache grows forever without limits, it can cause a memory leak-like problem.

userCache = MAP

FUNCTION loadUser(userId)
    user = FETCH user from database
    STORE user in userCache using userId
END FUNCTION

/*
If userCache never removes old users,
memory usage may keep increasing.
*/

Better Cache Policy

Use cache rules:
- Maximum size
- Expiration time
- Remove least-used items
- Clear old entries periodically

Event Listener Leak

In event-driven programs, memory leaks can happen when event listeners are not removed after they are no longer needed.

CREATE screen
REGISTER button click listener

CLOSE screen

/*
If listener is still registered,
the screen may remain referenced in memory.
*/

Better Version

CREATE screen
REGISTER button click listener

WHEN screen closes
    REMOVE button click listener
END WHEN

Resource Leak vs Memory Leak

A memory leak is specifically about memory. A resource leak is about other resources such as files, database connections, sockets, or locks.

However, resource leaks and memory leaks are closely related because resource objects may also occupy memory.

Signs of a Memory Leak

A memory leak may show several symptoms while the program runs.

How to Detect Memory Leaks

Memory leaks can be found through careful observation, testing, and debugging tools.

How to Prevent Memory Leaks

Preventing memory leaks requires careful memory and resource management.

Memory Leak in Manual vs Garbage-Collected Languages

Ownership and Memory Leaks

Ownership means knowing which part of the program is responsible for releasing memory.

Memory leaks often happen when ownership is unclear.

Important ownership questions:

Who created this object?
Who owns this memory?
Who must release it?
When should it be released?
Can another part of the program still use it?

Example: Memory Leak in Repeated Loop

/*
Wrong: Memory is allocated repeatedly but not released.
*/

ENTRY POINT
    FOR i FROM 1 TO 1000
        temp = ALLOCATE memory for temporary data
        USE temp

        /*
        Missing cleanup.
        */
    END FOR
END ENTRY POINT

This leaks memory repeatedly inside the loop.

Better Version

ENTRY POINT
    FOR i FROM 1 TO 1000
        temp = ALLOCATE memory for temporary data
        USE temp

        FREE temp
        SET temp = null
    END FOR
END ENTRY POINT

Example: Collection-Based Leak

/*
Potential leak in garbage-collected environment.
*/

logs = LIST

FUNCTION addLog(message)
    ADD message TO logs
END FUNCTION

/*
If logs keeps growing forever,
memory usage may keep increasing.
*/

Better Version

logs = LIST
MAX_LOGS = 1000

FUNCTION addLog(message)
    ADD message TO logs

    IF SIZE OF logs > MAX_LOGS THEN
        REMOVE oldest log
    END IF
END FUNCTION

Common Beginner Mistakes

Best Practices to Avoid Memory Leaks

Prerequisites Before Learning Memory Leak

Students should understand the following topics before learning memory leaks deeply:

Trace Table Example: Memory Leak

ptr = ALLOCATE memory
STORE 10 in ptr
ptr = ALLOCATE new memory

Practice Activity: Identify Memory Leak Risk

Identify whether each situation can cause a memory leak.

1. Memory is allocated but never freed.
2. A pointer is overwritten before freeing old memory.
3. A list stores old objects forever.
4. A file is opened and properly closed.
5. An event listener is registered but never removed.
6. A cache removes old items after a fixed limit.

Sample Answers

1. Memory leak risk
2. Memory leak risk
3. Memory leak risk
4. Good practice
5. Memory leak risk
6. Good practice

Mini Quiz

Interview Questions on Memory Leak

Quick Summary