Stacks ? how many will be there ??

SUNIL GUTTA

Hi friends

In my program i have one static block and i created 2 objects .. i think each object maintains different stack ?? am i right ..

can you please explain me the exact storage mechanism ?? is stack OS dependent ?? whats that exactly .

Share ur view in your own words plzz :)

Thank you

11 Replies

Know the answer? Post it — somebody with the same question will find it here.

Vulpes13y ago
Accepted answer
When you explicitly create a new thread in .NET, it's true that you create a new Thread object which behaves like any other object - it's allocated on the heap and is destroyed by the garbage collector when there are no longer any references to it.

However, that's where the similiarity ends - what goes on behind the scenes is different.

In simple terms, the CLR creates a new thread of execution and a call stack for it. When the thread starts, a 'stack frame' is created for the 'starting method' and pushed onto the stack. If this method calls another method, a stack frame is created for that method and pushed onto the stack, and so on.

A stack frame contains (amongst other things) memory slots for the method's parameters and local variables, if it has any, together with its return address.

Each time a method returns, its stack frame is popped from the stack and control returns to the method which called it until eventually the 'starting method' returns when the thread is destroyed and control returns to the thread which created the current thread. If the current thread is the 'main' thread then the process itself ends.

Although threads created by the CLR do not necessarily correspond one to one to OS threads, there will always be a least one OS thread in the background which is controlled by the scheduler. The CLR itself manages the relationship between .NET and OS threads.

When the Main() method starts, the main thread is created together with a stack for it and begins execution. New threads may be created either within the Main() method itself or within methods called directly or indirectly from it.
Vulpes13y ago
Just to get the terminology correct, a process represents the entire running application and contains one or more threads of execution.

Each thread has its own stack which contains one of more stack frames, one for each currently executing method called on that thread. So a call stack is essentially a collection of stack frames organised on a last in first out (LIFO) basis.

As each thread has its own stack, it follows that threads don't share stack memory. It's even possible for two (or more) threads to call the same method concurrently. As they have different stacks, each thread has its own copy of the method's local variables and/or parameters.

However, threads do share heap memory and if they are accessing it simultaneously this can lead to synchronization problems.

Remember also that when objects are created, they are always created on the heap. If a method contains a local variable of the object's type, the variable will contain a reference (or pointer) to the object, not the object itself.

All this will (hopefully) become clearer when you read the book :)
SUNIL GUTTA13y ago
yes i will buy the fallowing book .

Coming to threads humm i said same about this to my friend , he said stupidly or intelligently like this , Under main method or function in c++ when we created 2 threads they occupies memory in stack via frames not as separate stacks :( he said thread is a process --> process is a function to do i.e for doing function we create objects and if we create objects when we bind with data members will be allocated in stack or heap in frames not in separate stacks ??

Well earlier i said there exists 1mb stack only for .net app's .. so how come there exists multiple stacks for it like 1mb stack for each thread ?? .. incase if we using same stack for n threads cant we call as stack frame like before we done in class instances :)
Vulpes13y ago
Each stack contains a stack frame for each currently executing method.

So, if multiple threads have been created and are active, then there will be multiple stacks but each stack could contain any number of stack frames depending on how many methods have been called on that thread and have not yet returned.

If you want a detailed knowledge of how .NET works internally, then this is a good book to start from:

http://www.amazon.com/CLR-via-Microsoft-Developer-Reference/dp/0735667454
SUNIL GUTTA13y ago
Hey correct me , u said .net if there exists multiple threads under main function there will be mutiple stack frames or STACK directly .. I think stack frame ?? OS have only one stack i.e 1mb

Well how come you mastered upto this level any specific way to do so ?? Being a electronics i made my choice towards Software field quite lately but i am connected very well with it :)

So want to be as good as anyone :) just tell me how :) any books,strategies 2 prepare etc
Vulpes13y ago
Well I'm sure there are hacker tools which can be attached to a running .NET process and show the address of its threads' stacks and read (or even overwrite) values stored within it. The same also applies to heap memory.

This isn't a problem which is peculiar to .NET or Java - even unmanaged processes can be hacked in this way.

If you're creating two objects under the Main method then its stack frame will already contain memory slots to hold the heap addresses of those objects as they are created - the objects themselves won't be stored directly within the stack frame.

Those slots will probably be next to each other in stack memory but they may not be. In fact, local variables are often stored in processor registers for faster access rather than within the stack frame itself.

But if you're asking me whether all this is 100% secure, the answer is that it isn't - frankly, nothing is. Obfuscation helps but can still be reverse engineered by a determined hacker.

The best defence is not to give the hacker access to the machine running the software i.e. to run it on a remote server which communicates with local devices. Even then the local devices may still be able to be hacked, electronically or mechanically, or it may be possible to compromise the communication channel itself.
SUNIL GUTTA13y ago
Now i got everything fine :) is it possible to find stack address locations ??

As my sir told in ATM machines when we swipe card the object will be created for us , if so there will be heap & stack in ATM machines for sure for object storage :)

Hackers are ready to hack the object so that they can get pin or imp info that means they are getting access to stack memory ?? is stack via heap memory readable ?

One more doubt on stack ? It looks crazy but do calrify
-Well i said stack has 1mb size . for each object stack frame is allocated say i have created 2 objects under Main . 1ST object stores in say addr from 0000-0003 . when next object is created does it occupy immediate next stack frame .?? if so were is the security for object ?? we can get info of object to using obj one ?? encapsulation breaking right ? sorry if i am over smart or fool with my silly doubts :)

TY
SUNIL GUTTA13y ago
Superb explanation

So well lets say in multi-threading concept with one MAIN method there i created multiple threads using NEW keyword . . . As we speak each thread takes one stack (reference in heap) i.e so in my program there exists multiple threads so there will be multiple stacks right ??

if so

As i used NEW keyword for creation of threads it is just like creating different objects under class for data members ?? what's the difference ?

As each object of a class is independent of each other so why cant they share a seperate stack memory as they do in threads //

Is stack allocation is dependent on MAIN () ??

If miss something do clarify me . sorry for confusion created towards u :(

Ty for support
Vulpes13y ago
A stack (or call stack) is a data structure created by a process within the memory allocated to it by the operating system. It's not owned by the operating system as such though its design may be influenced both by the OS and the processor.

The default size of a stack in .NET is 1 megabyte.

The number of stacks in a .NET application has nothing to do with how many objects are created in that application. It simply depends on the number of threads in existence at any one time as mentioned in my earlier post.

All code in the Main() method of a .NET application will run on the main or start-up thread. The position is exactly the same with the main() function under a C++ application.

However, in .NET objects (i.e. instances of classes) are never created on the stack itself - they are created on the heap and class variables stored on the stack just contain references to them.

In contrast, objects in C++ can be created either on the heap or on the stack.

So what your friend said about the main() function is essentially correct though the stack is only under the control of the OS to the extent that it's contained within the memory allocated by it to a process and because the OS (ultimately) controls thread allocation and scheduling.
SUNIL GUTTA13y ago
well ty for quick reply

Can you please explain me in detail . like in terms Do operating system own STACK ?? if so how many stacks it will have ? stack memory size (32-bit) ?? ..

Coming to main point there will be n stacks for n objects right ?? Do all stacks share same memory in ONE STACK memory under control of OS if exists (i donno it exists single or multiple) . . .

Hope u got my trouble ?
-actually my friend said in c++ all functions take n objects under Main share same stack (single main single stack). He asked me & i said in c# terms well each object and its calling members share unique stack memory :) He in-turn turned down my argument i am wrong & said what ever the language, STACK is under control of OS said blah blah ??

- so whats happening who is ri8 & wrong and ur view :)
Vulpes13y ago
Quite simply each thread in .NET has its own stack.

So, in a single-threaded application, there's just one stack.