JVM的实际内存分配以及它们有何不同？

Question

This might seem a lot of questions but they are all interrelated.I'm little confused as in where is the heap space allocated and where is the stack memory located ?
If both are present in main memory then why it is said that stack memory is easier to access and why can't we allocate objects in stack memory ?
Since classes are stored in PermGen where is this space allocated and how does it differ from heap space and where are constant strings stored ?

Answer 1

1. "Where are the heap and stack allocated?" The accepted answer to this question covers this. Each thread gets its own stack and they all share one heap. The operating system controls the exact memory locations of the stacks and heap items and it varies.
2. "Why is stack memory easier to access" Each thread has its own stack, so there are fewer concurrency issues. The stack and heap are both eligible for caching in the L1, L2, and L3 portions of the memory hierarchy , so I disagree with Daniel's answer here. Really I would not say that one kind of memory is particularly easier to access than the other.
3. "Why can't we allocated objects in stack memory?" This is a design decision taken by the JVM. In other languages like C/C++ you can allocate objects on the stack. Once you return from the function that allocated that stack frame such objects are lost. A common source of errors in C/C++ programs is sharing a pointer to such a stack allocated object. I bet that's why the JVM designers made this choice, though I am not sure.
4. The PermGen is another piece of the heap. Constant strings are stored here for the lifetime of the JVM. It is garbage collected just like the rest of the heap.

Answer 2

If both are present in main memory then why it is said that stack memory is easier to access

There's speed of access and speed of allocation. Stack allocation (as in alloca ) is fast because there's no need to search for an unused block of memory. But Java doesn't allow stack allocation, unless you count the allocation of new stack frames.

Accessing stack memory is fast because it tends to be cached. Not only are locals near one another, they are also stored very compactly.

and why can't we allocate objects in stack memory ?

This would be useful, but dangerous. A user could allocate an object on the stack, create references to it from permanent objects, and then try to access the object after the associated stack frame is gone.

It's safe to store primitives on the stack because we can't create references to them from elsewhere.

Since classes are stored in PermGen where is this space allocated and how does it differ from heap space and where are constant strings stored ?

PermGen is just another heap space. String literals are stored in the literal pool, which is just a table in memory which is allocated when a class is loaded.