Memory allows programs to run efficiently.  In-memory operations are significantly faster than disk operations.  Using memory, applications can hold references to objects and data structures without having to perform costly read/write operations to a database or remote service.

Memory is a limited resource.  An OS only has so much memory available to run applications.  When you run a Java application, the OS allocates a specified amount of its memory to the JVM for running your application.

All of the classes, methods, variables, etc. you define in your Java application rely on memory.  When you create a new object in Java, memory is used to "save" the object for use in your program.  If your application uses too much memory, your application can crash...

Fortunately, Java handles the allocation and use of memory for you.  Unlike other programming languages, Java automatically releases memory for you when objects, variables, etc. are no longer being used.  The compiler also optimizes your code to maximize the efficiency of memory being used by your application.

This does not mean you won't still run into memory management issues using Java. If you've ever seen a StackOverflowError or OutOfMemoryError exception and your application crashes then you've experienced the pain of poor memory management.

This is why it's important to understand how Java memory management works under the hood.  While the details behind how Java handles memory is rather complicated and overwhelming, understanding the difference between Java Heap vs Stack is a great way to explore what's happening under the hood...

Understanding Heap vs Stack with an example...

Let's take the following simple Java program as a starting point:

    private static void printObject(Object param) {

    public static void main(String[] args) {

This simple program creates a new Object and prints the string representation.

For every variable we declare, for every object we create, for every method we call, the JVM will allocate memory to either Stack Memory or Heap Space.

The Heap Space is a global memory space for storing objects and classes at runtime. When we create a new object via new Object() this stores the newly created object in the heap space. Similarly, our printObject method stores the String str in the heap space.

When our program executes, the methods hold references to these objects.

The Heap Space allows for the dynamic allocation/deallocation of memory.  It provides a lean approach to handling memory as objects can be efficiently referenced and reused when possible.  Without heap space, objects would be allocated to memory more than necessary and dynamic memory management wouldn't be possible.

<a id=29 href='https://www.stackchief.com/blog/Garbage%20Collection%20in%20Java'>Garbage collection</a> is the automated mechanism by which the Heap releases memory when objects are no longer being used. The garbage collection process is rather complicated and outside the scope of understanding the basics of Heap vs Stack but here is a brief description of how it works:

Garbage collection is an automatic process.  It's implementation varies based on which JVM you are using, however some common concepts apply to these variations.

First, the garbage collector marks any unreferenced objects not being used by the application.  Then the collector deletes these unused objects from memory.

The garbage collector categorizes objects by age so that it can efficiently remove most short-lived objects.  These categories include:

young generation: newly created objects

old generation: objects that survive multiple garbage collection "cycles" are moved to this stage

permanent generation: metadata including classes and method are stored here

A "minor garbage collection event" will remove unused objects from the young generation whereas a "major garbage collection event" will remove objects from the older generations.

By categorizing objects by age, the garbage collector is able to free up memory efficiently and automatically.  This allows Java developers to write code without managing memory allocation manually.

Confused? Be sure to check out <a href='https://www.stackchief.com/blog/Garbage%20Collection%20in%20Java'>Garbage collection in Java</a>.

Stack memory is used for the execution of a single thread in Java. It stores primitive types like our int i and references to the objects stored in the Heap space.

Stack memory follows a last in first out (LIFO) approach to memory access. When our program executes, the main() method gets invoked. This results in a block of memory being added to the stack. This memory block will hold the primitive variable i along with a REFERENCE to the newly created new Object(). Remember that the object itself is stored in the heap space.

Notice that the main() method invokes the printObject() method. When this happens, a new memory block is added to the top of the stack. This memory block will hold a reference to the str.

When the printObject() method finishes execution, the memory block is removed from the stack and becomes free.

IMPORTANT: Notice how our main() method passes our newly created myObject to the printObject() function...

When this printObject() method gets invoked, it creates its own reference for the passed in param. While both methods create their own references to myObject, both methods reference the same object stored in the heap space..

This important fact sheds light on the heap and stack work together to efficiently manage memory in Java.

The Heap is a global space of memory.  It gets allocated by the JVM when your program starts and is used as long as the application is running.  Objects stored in the heap space are available anywhere in the application.  This also means the heap space IS NOT thread safe.

The stack IS thread safe because it exists on a per thread basis.  The stack releases memory immediately after a method finishes execution.

Memory accessed through the heap space is complex.  Different spaces (young generation, old generation) are used to essentially mark the lifetime of resources.  This is fundamental to the garbage collection process but also very complex.

Memory accessed through the stack is simple.  For every method that gets invoked, a new memory block is added to the top of the stack.  When the method is done executing, the block is freed and "popped" off the top of the stack.  This refers to the LIFO approach to Stack memory access.

Heap space is not thread safe while Stack memory is thread safe.

Heap space is global while Stack memory is local to current method/thread.

Heap space access is determined by a young generation/old generation tracking system while Stack access follows a simple LIFO pattern.

Heap space stores all objects created by Java application while Stack memory stores only primitive types and references to those objects.

Heap space is slower to access than Stack memory.

Java Heap vs Stack including examples, java memory management, garbage collection, why the heap, and key differences.

Java Heap vs Stack

Can we call garbage collector forcefully in Java

Can we call garbage collector forcefully in Java?

How long does it take to become a software engineer

How long does it take to become a software engineer?

it's funny how it takes articles like this to get to the bottom of things sometimes.  While there are plenty of official java docs out there, this actually tells you (in a nutshell) what version is right for you.

Well. My company standard it's openJDK 8 since 2019... Cheers!

juanrios.com@localhost

thank you, I finally realize that Java 8 is the most popular version.

Evgeny Ivanov

Alexander Joseph

A discussion surrounding the different versions of Java including the difference between SE and EE as well as key features of Java 7, 8, and 9.

Which Version of Java Should You Use?

How to read a CSV file in Java with examples including reading  into an ArrayList, parsing a csv file using scanner, reading with a header, and reading by column name.

How to read a CSV file in Java | with examples

What is a good salary for a software engineer

What is a good salary for a software engineer?

The Kafka consumer poll() method fetches records in sequential order from a specified topic/partitions.

This poll() method is how Kafka clients read data from Kafka.

When the poll() method is called, the consumer will fetch records from the last consumed offset.

What is Kafka consumer poll?

In general, concurrency is the ability to perform parallel processing with no affect on the end result.

In Kafka, the parallel consumption of messages is achieved through consumer groups where individual consumers read from a given topic/partitions in parallel.  This works because each consumer in the instance is assigned a given number of partitions within the topic, allowing all messages to be read in parallel.

This is a key advantage of Kafka and makes it superior in terms of processing power on the consumer side.

What is Kafka Consumer Concurrency?

To me, it's not about "popularity" as much as it's about what you're trying to do.  For certain things, language A is better than B.  There are situations where Java is the best to work with.  For example, if you're using Kafka then using the Java client is going to be the easiest way to integrate.

On the other hand, if you're a front end developer who wants to build a full stack solution, then JavaScript is a much better option for you because you already use it on the frontend and can easily apply it to NodeJs framework etc on the backend.

I've heard Go and Swift are giving Java a serious run for it's money in 2021...is this true?

Is Java losing popularity?

No. NodeJs is not single threaded.  The NodeJs event loop operates on a single thread yes, but the async blocking operations are delegated to separate worker threads.  These threads notify the main thread when they are done processing.

Yuzo_Koyama

How long does it take to become a software engineer?

What is Kafka Consumer Group ID?