Introduction

In programming, a resource is anything that a program needs to acquire before use and release after use.

Examples of resources include memory, files, database connections, network sockets, locks, streams, handles, temporary files, and external service connections.

Resource management means handling these resources properly so that a program remains stable, efficient, and reliable.

Good resource management prevents memory leaks, file leaks, connection leaks, deadlocks, performance issues, and application crashes.

Easy Real-Life Example

Library Example:
Borrow book  → Acquire resource
Read book    → Use resource
Return book  → Release resource

Programming Example:
Open file    → Acquire resource
Read file    → Use resource
Close file   → Release resource

If you never return the book, other students cannot use it. Similarly, if a program does not release resources, other parts of the system may not be able to use them.

What is a Resource?

A resource is a limited system item or capability that a program uses during execution.

Resources are usually limited. That means a system cannot provide unlimited memory, unlimited open files, unlimited database connections, or unlimited locks.

Common Resources in Programming

Resource Lifecycle

Most resources follow a simple lifecycle.

1. Acquire resource
2. Use resource
3. Release resource

This may look simple, but many real-world bugs happen because the release step is forgotten or skipped during an error.

Simple Resource Management Example

/*
Resource management idea.
*/

ENTRY POINT
    file = OPEN "students.txt"

    READ data from file

    CLOSE file
END ENTRY POINT

In this example, the file is opened, used, and then closed. This is proper resource management.

What Happens If Resources Are Not Released?

If resources are not released properly, the program may waste system capacity and become unstable.

File Resource Management

Files are common resources. A program may open a file to read or write data.

After using the file, the program should close it.

Wrong Example

/*
Wrong: File is opened but not closed.
*/

ENTRY POINT
    file = OPEN "report.txt"

    READ data from file

    /*
    Missing:
    CLOSE file
    */
END ENTRY POINT

Better Example

ENTRY POINT
    file = OPEN "report.txt"

    READ data from file

    CLOSE file
END ENTRY POINT

Closing the file releases the file handle and helps prevent file-related resource leaks.

Database Connection Management

Database connections are limited resources. A database server can handle only a limited number of active connections.

If a program opens database connections and never closes or returns them to a pool, the application may eventually fail to connect to the database.

Wrong Example

FUNCTION getStudents()
    connection = OPEN database connection

    result = RUN query using connection

    RETURN result

    /*
    Connection is not closed.
    */
END FUNCTION

Better Example

FUNCTION getStudents()
    connection = OPEN database connection

    result = RUN query using connection

    CLOSE connection

    RETURN result
END FUNCTION

In real applications, the connection may be returned to a connection pool instead of being fully destroyed.

Network Socket Management

Network sockets are used for communication between systems.

If sockets are not closed properly, they can remain open and consume system resources.

socket = OPEN connection to server

SEND request
RECEIVE response

CLOSE socket

Proper socket cleanup is important in servers, APIs, messaging systems, and network applications.

Lock and Mutex Management

Locks are used in programs where multiple tasks or threads access shared data.

A lock should be released after the protected work is complete. If a lock is not released, other tasks may wait forever.

Wrong Example

LOCK sharedData

UPDATE sharedData

/*
Missing:
UNLOCK sharedData
*/

Better Example

LOCK sharedData

UPDATE sharedData

UNLOCK sharedData

Poor lock management can cause deadlocks, blocked threads, and frozen applications.

Resource Management and Error Handling

Resource management becomes more important when errors occur.

If an error happens before the release step, the resource may remain open or locked.

Risky Example

file = OPEN "data.txt"

READ data from file

IF error occurs THEN
    RETURN
END IF

CLOSE file

If the function returns because of an error, the file may never be closed.

Safer Pattern

file = OPEN "data.txt"

TRY
    READ data from file
    PROCESS data
FINALLY
    CLOSE file
END TRY

The FINALLY block represents cleanup logic that should run even if an error occurs.

Automatic Cleanup Patterns

Many programming languages provide automatic cleanup patterns.

These patterns help ensure that resources are released even when an error occurs.

Scope-Based Resource Management Example

Some languages support scope-based cleanup, where a resource is automatically released when a block ends.

WITH file = OPEN "data.txt"
    READ data from file
END WITH

/*
File is automatically closed when the block ends.
*/

This style reduces the chance of forgetting to release a resource.

Resource Management and Ownership

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

Without clear ownership, resources may be released too early, too late, or never released at all.

Ownership questions:

Who opened this file?
Who owns this connection?
Who must close this stream?
Who should release this lock?
When should cleanup happen?

Memory Management vs Resource Management

Memory management and resource management are related, but they are not exactly the same.

Resource Leak

A resource leak happens when a program acquires a resource but does not release it.

OPEN file
READ file

/*
File is not closed.
This is a resource leak.
*/

Resource leaks are similar to memory leaks, but they may involve non-memory resources such as files, connections, sockets, and locks.

Example: Resource Leak in Loop

/*
Wrong: Opens many files but does not close them.
*/

FOR EACH fileName IN fileNames
    file = OPEN fileName
    READ file
END FOR

If many files are opened and not closed, the program may run out of available file handles.

Better Version

FOR EACH fileName IN fileNames
    file = OPEN fileName

    TRY
        READ file
    FINALLY
        CLOSE file
    END TRY
END FOR

Resource Pooling

Some resources are expensive to create repeatedly. Instead of creating and destroying them every time, programs may use a resource pool.

A pool keeps a limited number of reusable resources.

Resource pool idea:

1. Borrow resource from pool.
2. Use resource.
3. Return resource to pool.

Database connection pools and thread pools are common examples.

Connection Pool Example

connection = GET connection from pool

TRY
    RUN database query
FINALLY
    RETURN connection to pool
END TRY

Returning the connection to the pool allows another request to reuse it.

Why Resource Management Affects Performance

Poor resource management can reduce performance because resources are limited and expensive.

Resource Management and Reliability

Reliable software must clean up resources even when errors happen.

A program should not depend on the “happy path” only. It should also handle failure paths.

Good resource management checks:

- What if opening fails?
- What if reading fails?
- What if processing fails?
- What if the function returns early?
- What if an exception occurs?
- Will the resource still be released?

Common Beginner Mistakes

Best Practices for Resource Management

Prerequisites Before Learning Resource Management

Students should understand the following topics before learning resource management deeply:

Trace Table Example: File Resource Lifecycle

file = OPEN "data.txt"
READ file
CLOSE file

Practice Activity: Identify Resource Management Issue

Identify the resource management issue in each situation.

1. A file is opened but never closed.
2. A database connection is returned to the pool after use.
3. A lock is acquired but an error occurs before unlock.
4. A network socket is closed after communication ends.
5. A function opens many files inside a loop but does not close them.
6. A temporary file is deleted after processing.

Sample Answers

1. Resource leak
2. Good practice
3. Deadlock/resource leak risk
4. Good practice
5. Resource leak risk
6. Good practice

Mini Quiz

Interview Questions on Resource Management

Quick Summary