Method local variables and stack and heap

While reading on Thread Safety I came across this issue. If I'm correct method local Primitives and object references lives inside a stack and actual objects pointed by the references inside the stack lives in the heap.

But when it comes to method local non primitive object initialization, wouldn't that cause a concurrency issue ? I mean if the method locals non primitives lives in the heap and only the pointers lives in the stacks, isn't it the same as of instance variables ?

Can someone please help me to understand this....

PS

Think of two threads with each having two stacks of their own and one heap. What I understood is that the two threads keep their method local primitive variables inside their stacks. I have no issue with that.

But what if we have a method with non primitive method local variables ? Then if the object for that variable is stored inside the heap, both the threads will have the access to the same object, won't they ? So if that's the case there would be Sync problems.

That is what I'm asking.

Thanks

---

Both threads could have access to the same object if they both have a reference to the object. If you have a method like the following:

public String concat(String a, String b) {
    StringBuilder builder = new StringBuilder();
    builder.append(a);
    builder.append(b);
    return builder.toString();
}

The StringBuilder object is indeed in the heap, but only one thread has a reference to this object. No other thread can have a reference to this StringBuilder. So it's inherently thread-safe.

If, on the contrary, you have the following:

public String concat(String a, String b) {
    final StringBuilder builder = new StringBuilder();
    new Thread(new Runnable() {
        @Override
        public void run() {
            builder.append("haha!");
        }
    }).start();
    builder.append(a);
    builder.append(b);
    return builder.toString();
}

Then you have a thread-safety issue, because you shere the locally created object reference with another thread, and StringBuilder is not thread-safe.

---

But what if we have a method with non primitive method local variables ? Then if the object for that variable is stored inside the heap, both the threads will have the access to the same object, won't they ? So if that's the case there would be Sync problems.

I wonder why you will think the two references will refer to the same object.

The creation of the object referred is explicitly done by new (or other similar method, but idea is the same)

Therefore, unlike in C++, if you are declaring this in Java

Foo foo;

there is no Foo object instantiated. foo is just a pointer pointing to nothing.

This will create you a Foo object instance in heap.

Foo foo = new Foo();

If two thread is running this piece of code, thread 1 will have a Foo reference in stack, and ask to allocate a new Foo object in heap, and then assign the address of that Foo obj to the reference foo . Thread 2 is doing the same. Note that Thread 2 is also asking to allocate a new Foo object, it will be a different object from what Thread 1 is allocated.

That's the basic (and much simplified) idea.

---

But what if we have a method with non primitive method local variables ? Then if the object for that variable is stored inside the heap, both the threads will have the access to the same object, won't they ? So if that's the case there would be Sync problems

您部分回答了您自己的问题。该引用值存储在堆栈中，但实际的对象内容存储在堆中，并且当您调用新的Object（）时，每个线程创建将存储在堆中的不同新对象，并且每个线程访问使用存储在其自己堆栈中的引用值创建的对象

链接地址: http://www.djcxy.com/p/79086.html

上一篇: Java变量放置在堆栈或堆上

下一篇: 方法局部变量和堆栈和堆