OPERATING SYSTEM: Difference between Stack and Heap

 

    Stack is used for static memory allocation and heap is used for dynamic memory allocation, both are located in the RAM of the computer.

    Variables allocated on the stack are stored directly in the memory. Access to this memory is very fast. This allocation is processed when the program is compiled. When a function or a method calls another function which in turn calls another function, etc., the execution of all these functions remains suspended until the last function returns its value. The stack is always reserved in LIFO order, the last reserved block is always the next block to be released. This makes stack tracking very simple, releasing a block from the stack is nothing more than adjusting a pointer.

    Memory is allocated to the variables assigned to the memory segment at runtime and access to this memory is a little slower, but the size of the memory segment is only limited by the size of the virtual memory. The elements of the heap have no dependency on each other and can always be accessed randomly at any time. You can allocate a block at any time and release it at any time. This makes it much more complex to keep track of which parts of the heap are allocated or free at any given time.

    You can use the stack if you know exactly how much data you need to allocate before compiling and if it is not too large. You can use the heap if you don't know exactly how much data you will need at runtime or if you have to allocate a lot of data.

    In a multi-threaded situation, each thread will have its own completely independent stack but will share the heap. The stack is thread specific and the heap is application specific. The stack is important to take into account in exception handling and thread executions.

Key difference between Heap and Stack:

Stack:

•     Very fast access
•     No need to explicitly deallocate variables
•     Space is managed efficiently by the processor, memory  will not be fragmented
•     Local variables only.
•     Limit on stack size (depends on operating system).
•     Variables can't be resized.

Heap:

•     Variables are globally accessible
•     No limit on memory size
•     (Relatively) slower access
•     Efficient use of space is not guaranteed, memory can become fragmented over time when blocks  of memory are allocated and then released
•     You have to manage the memory (you are responsible for allocating and releasing variables)
•     Variables can be resized using realloc()

In short:

    When should you use the heap and when should you use the stack? If you need to allocate a large block of memory (for example, a large array or structure) and you need to keep that variable for a long time (like a global variable), then you should allocate it on the heap. If you have relatively small variables that need to persist only as long as the function that uses them is active, you should use the stack, it is easier and faster. If you need variables such as arrays and structures that can change size dynamically (for example, arrays that can grow or shrink as needed), you will probably need to allocate them on the heap and use dynamic memory allocation functions such as malloc(), calloc(), realloc() and free() to manage this memory "by hand". We will talk about dynamically allocated data structures after we talk about pointers.

THANK YOU for reading

You Tech 56

Follow us on social medias: linktr.ee/youtech56