What is a native method and necessities?

The method is implemented in "native" code. That is, code that does not run in the JVM. It's typically written in C or C++.

Regular Java class definitions are compiled to bytecode, held in class files. This bytecode is platform independent, and is translated into specific instructions for the architecture and operating system running the bytecode at run time.

Java native code necessities

1. We need to run some platform-specific code, perhaps referencing a platform specific library or making some operating system–level calls, or making some operating system–level calls.

2. Hardware access and control.

3. Use of commercial software and system services[hardware related].

4. Use of legacy software that hasn't or cannot be ported to Java.

5. Using native code to perform time-critical tasks.

A native method is well-defined header in C or C++, identifying the class name, the Java method name, as well as its parameters and return type. When your code is loaded into the JVM, you need to register your native code so that it knows exactly what needs to be run when your native method is called.

Object generations - Java heap terminology: young, old and permanent generations?

The heap is split into several different sections, called generations.

As objects survive more garbage collections, they are promoted into different generations. The older generations are not garbage collected as often. Because these objects have already proven to be longer lived, they are less likely to be garbage collected.

1. Eden Space

2. Survivor Space

3. Tenured Generation

4. Permanent Generation, or PermGen.

When objects are first constructed, they are allocated in the Eden Space. If they survive a garbage collection, they are promoted to Survivor Space, and should they live long enough there, they are allocated to the Tenured Generation. This generation is garbage collected much less frequently.

There is also a fourth generation, called the Permanent Generation, or PermGen. The objects that reside here are not eligible to be garbage collected, and usually contain an immutable state necessary for the JVM to run, such as class definitions and the String constant pool.

Note:

PermGen space is planned to be removed from Java 8, and will be replaced with a new space called Metaspace, which will be held in native memory.

Using the PermGen Space

For most applications, the PermGen area contains traditional class definitions, String constants, and not much else. Newer languages running on the JVM, such as Groovy, have the capability to create dynamic class definitions, and when used under load, this can fill up the PermGen space easily. You must be careful when creating many dynamic class definitions; and you may need to tweak the default memory allocation for PermGen space.

How is memory allocated?

The new keyword allocates memory on the Java heap. The heap is the main pool of memory, accessible to the whole of the application.

If there is not enough memory available to allocate for that object, the JVM attempts to reclaim some memory from the heap with a garbage collection.

If it still cannot obtain enough memory, an OutOfMemoryError is thrown, and the JVM exits.

Stack vs. Heap Memory

Java Heap Memory

Heap memory is used by java runtime to allocate memory to Objects and JRE classes. Whenever we create any object, it’s always created in the Heap space.

Garbage Collection runs on the heap memory to free the memory used by objects that doesn’t have any reference. Any object created in the heap space has global access and can be referenced from anywhere of the application.

Java Stack Memory

Java Stack memory is used for execution of a thread. They contain method specific values that are short-lived and references to other objects in the heap that are getting referred from the method.

Stack memory is always referenced in LIFO (Last-In-First-Out) order. Whenever a method is invoked, a new block is created in the stack memory for the method to hold local primitive values and reference to other objects in the method. As soon as method ends, the block becomes unused and become available for next method.

Difference between Heap and Stack Memory

Heap memory	Stack memory
Heap memory is used by all the parts of the application.	whereas stack memory is used only by one thread of execution.
Whenever an object is created, it’s always stored in the Heap space and stack memory contains the reference to it.	Stack memory only contains local primitive variables and reference variables to objects in heap space.
Objects stored in the heap are globally accessible.	Stack memory can’t be accessed by other threads.
Heap memory is more complex because it’s used globally and  Heap memory is divided into Young-Generation, Old-Generation etc.	Memory management in stack is done in LIFO manner.
We can use -Xms and -Xmx JVM option to define the startup size and maximum size of heap memory.	We can use -Xss to define the stack memory size.
If heap memory is full, it throws java.lang.OutOfMemoryError: Java Heap Space error.	When stack memory is full, Java runtime throws java.lang.StackOverFlowError.
	Because of simplicity in memory allocation (LIFO), stack memory is very fast when compared to heap memory.
Heap memory lives from the start till the end of application execution.	Stack memory is short-lived.
Stack memory size is very less when compared to Heap memory.