Thread: Stack Memory question (understanding)

I was recently running into some issues with non-static variables, I think it might be my tenuous understanding of stack memory. So java only gets one stack per thread? And if this is the case it seems really inefficient to hold several objects instance variables in one stack considering I rarely load them in any order that will aid LILO functionality. This makes me want to use an array of threads to handle some objects to aid the memory. So I suppose the real questions are: A, does java only have one stack per thread, B, what takes place in a stack to delete values below the last in.

The issue is less of my concern I am mostly just curious about this: "So I suppose the real questions are: A, does java only have one stack per thread, B, what takes place in a stack to delete values below the last in." I feel confident with a better grasp of these questions I can move forward.

I did mention in my initial post some changes I could make, but I would like to just move past this and deal strictly with the questions I asked if you don't mind.

Well for the sake of this conversation let us just trust in my diagnostic ability. The google term you suggested answered one of my questions, but I am still thinking it is seriously inefficient to have one thread handle several objects stack variables. What would java do if I want to delete an index in the stack below the last?

For norm this is the one thing I mentioned.

This makes me want to use an array of threads to handle some objects to aid the memory

When I said:

What would java do if I want to delete an index in the stack below the last?

It was in an indirect manner. Say I have some values under a region in the stack now what if I happen to delete an object's instances below the last region; my question was how does java handle an event like this, or how does it prevent it form happening. Because I have several objects with instances on one thread (one stack then), how does java deal with a request to delete an early objects instances and still maintain the latest?

When I say delete below that region I simply mean if I declare some values and they are entered onto the stack, then I get a new object and declare some values if I delete the first object how does java maintain LILO while removing the first object's values? The only alternatives I can see is java won't delete a lower entry, or it copies all higher entries onto a new stack except the desired index (unlikely considering how inefficient it would be). Which makes me want to try some things differently like the aforementioned option.

Instantiate an object set values, then instantiate a new object and set values now try and delete the former object (all on the same thread).

Reading back over this thread, it's all over the place, and I'm not sure what you're asking any more. It ends by posing a simple task that could be accomplished by:

MyObject object1 = new MyObject();
MyObject object2 = new MyObject();

object1 = null; // nominates object1 for garbage collection

Somehow you've mixed together the concepts of stack and heap memory, which are not under the programmer's control in Java, and the data structure "stack," which the programmer has the degree of control provided by the data structure's interface. You might search and read more on stack/heap memory in Java and then garbage collection. I think all that you need to know about those subjects is included in Effective Java.

Originally Posted by Norm

Can you post some code that shows what you are trying to say?

int s = 1;
int b = 13;

Assume they are both local, and what if I want to delete s first?

Originally Posted by KevinWorkman

How would you delete s? And what does this have to do with the stack? And how has this lead to problems in your code?

Again, I think you're confused about the basics, and you're asking questions that you have no way of really understanding at this point. I suggest coming back to this when you understand more about scope, the garbage collector, and program execution.

Are you saying that local variables (non-static) aren't stored in the stack (I realize references might be stored in heap)? Heap is for objects and static variables is it not, so garbage collector wouldn't really apply? I delete S by making it's class reference null.

Never mind I found it. You guys were right from the beginning I should have just done some more research. It has to do with re-arranging to delete an item not on the top, I can do this in many different ways. And, no you cannot make an int null, but you can make the instance class that it is held in null like I said above. Which should invoke a stack iteration if my understanding is correct.

Originally Posted by KevinWorkman

So your question was about the stack data structure and not the thread stack this whole time?



Your understanding is not correct. Pointing a reference to null does not affect the method stack in any way.

Okay so only local variables are stored in stack. Which are handled when it returns. My question was how does the JVM delete a lower iteration (push/rearranging). And, what do you mean because to my knowledge java only uses stacks with respect to threads.

This is all irrelevant, and I assure you my understanding is solid (thanks to you folks); likely your digression is latency from my poor explanation and communication. I was messing around and for the record stack memory should be well understood by programmers, for reaching the upper system limits of even the most impressive computers isn't that hard when dealing with recursion (I will be using thread arrays to handle large events).