深入内存

今天在网上看到了这样一个问题，“如果malloc 了一块字符串的内存，然后，它改变了这个字符串的大小，问会不会有一部分内存没有被释放掉。”这个问题，以前的确没有仔细想过。

　　当然，我觉得是肯定会释放掉的，但是一直没有了解过free 的原理，不敢乱说。我看了一下操作系统的内存管理，基本上是这样的，当然各个系统的实现不一样。

　　操作系统管理内存，维护了一个空闲内存链表，malloc从个链表中选出一个来使用，每个内存块都有一个头部来表示这个内存的基本信息，如内存大小，所以free 时候能够记住原来指针所指的内存大小，而不是用内存块中是否有 \0 来临时计算指向内存的大小，不要字符串的计算长度的方法所误导。

　　还有一点要注意的就是，系统在free 内存的时候，记住的只是 malloc 时候的地址，和分配内存的大小。

　　比如 char *p = (char *)malloc(10); 就会产生分配10个字节。如果你把指针的地址改变了 p = p + 1; 然后 free 就要出问题了。程序会崩溃。

　　如果一定要改变指针的值，建议这样做 char *newp = p; 然后改变 newp = newp + 1 ，最后 free(p);

　　还有一点要注意，一个长度为10 的字符串要占用 11个字节。因为还有一个 ‘\0‘, 所以分配内存的时候要分配 lenght + 1 的大小。

//********************************************************************************************************

使用C语言编程，实际上使用的内存只有一种——虚拟内存。根据功能的不同在C语言中又将虚拟内存为分三类：栈区、堆区、静态数据区，无论单一变量还是数组，其内存分配都是如此。其中，栈区、静态数据区、堆区都会有编译器负责分配、操作系统负责管理，程序员可以在堆区使用malloc()来动态分配堆内存。

1、栈区：一般每一个函数对应一个栈区，在编译原理中称为栈帧。比如下面的代码：

int main()
{
//定义一个有20个int元素的数组。此时数组a分配的虚拟内存称为栈区，有编译器自行分配。
    int a[20] = {0}; 
    return 0;
}

2、静态数据区：这实际上对应于生成的可执行文件的.data区段，因为这个区段在生成的可执行文件中，因此是“静态的”。比如下面的代码：

//定义一个20个int元素的全局数组，此时数组分配的虚拟内存称为静态数据区，有编译器自行分配。
int g_a[20]; 
int main() { return 0;}

3、堆区：堆区是最复杂的，有操作系统负责堆管理，但是当用C语言编译器生成一个可执行文件并且运行时，它会默认建立一些堆。拿Windows来说，每一程序运行，它会建立至少两个堆，一个是默认堆，一个是new堆。比如下面的代码：

int main()
{
    int *pa = (int*)malloc(sizeof(int)*20);//分配20个int元素大小的堆空间。
    return 0;
}


Even though with the .NET framework we don‘t have to actively worry about memory management and garbage collection (GC), we still have to keep memory management and GC in mind in order to optimize the performance of our applications. Also, having a basic understanding of how memory management works will help explain the behavior of the variables we work with in every program we write.  In this article I‘ll cover the basics of the Stack and Heap, types of variables and why some variables work as they do.

There are two places the .NET framework stores items in memory as your code executes.  If you are not yet familiar with them, let me introduce you to the Stack and the Heap. Both the Stack and Heap help us run our code. They reside in the operating memory on our machine and contain the pieces of information we need to make it all happen.

Stack vs. Heap: What‘s the difference?

The Stack is more or less responsible for keeping track of what‘s executing in our code (or what‘s been "called").  The Heap is more or less responsible for keeping track of our objects (our data, well... most of it; we‘ll get to that later).

Think of the Stack as a series of boxes stacked one on top of the next.  We keep track of what‘s going on in our application by stacking another box on top every time we call a method (called a Frame).  We can only use what‘s in the top box on the Stack.  When we‘re done with the top box (the method is done executing) we throw it away and proceed to use the stuff in the previous box on the top of the Stack. The Heap is similar except that its purpose is to hold information (not keep track of execution most of the time) so anything in our Heap can be accessed at  any time.  With the Heap, there are no constraints as to what can be accessed like in the Stack.  The Heap is like the heap of clean laundry on our bed that we have not taken the time to put away yet; we can grab what we need quickly. The Stack is like the Stack of shoe boxes in the closet where we have to take off the top one to get to the one underneath it.



The picture above, while not really a true representation of what‘s happening in memory, helps us distinguish a Stack from a Heap. The Stack is self-maintaining, meaning that it basically takes care of its own memory management.  When the top box is no longer used, it‘s thrown out.  The Heap, on the other hand, must worry about Garbage collection (GC), which deals with how to keep the Heap clean (no one wants dirty laundry laying around, it stinks!).

What goes on the Stack and Heap?

We have four main types of things we‘ll be putting in the Stack and Heap as our code is executing: Value Types, Reference Types, Pointers, and Instructions.

Value Types:

In C#, all the "things" declared with the following list of type declarations are Value types (because they are from System.ValueType):

bool
byte
char
decimal
double
enum
float
int
long
sbyte
short
struct
uint
ulong
ushort


Reference Types:

All the "things" declared with the types in this list are Reference types (and inherit from System.Object, except, of course, for object which is the System.Object object):

class
interface
delegate
object
string


Pointers:

The third type of "thing" to be put in our memory management scheme is a Reference to a Type. A Reference is often referred to as a Pointer. We don‘t explicitly use Pointers, they are managed by the Common Language Runtime (CLR). A Pointer (or Reference) is different than a Reference Type in that when we say something is a Reference Type, it means we access it through a Pointer. A Pointer is a chunk of space in memory that points to another space in memory.  A Pointer takes up space just like any other thing that we‘re putting in the Stack and Heap and its value is either a memory address or null.



Instructions:

You‘ll see how the  "Instructions" work later in this article...

How is it decided what goes where? (Huh?)

Ok, one last thing and we‘ll get to the fun stuff.

Here are our two golden rules:

A Reference Type always goes on the Heap; easy enough, right?
Value Types and Pointers always go where they were declared. This is a little more complex and needs a bit more understanding of how the Stack works to figure out where "things" are declared.


The Stack, as we mentioned earlier, is responsible for keeping track of where each thread is during the execution of our code (or what‘s been called).  You can think of it as a thread "state" and each thread has its own Stack.  When our code makes a call to execute a method the thread starts executing the instructions that have been JIT compiled and live on the method table, it also puts  the method‘s parameters on the thread Stack. Then, as we go through the code and run into variables within the method, they are placed on top of the Stack. This will be easiest to understand with an example.

Take the following method:

public int AddFive(int pValue)          {                int result;                result = pValue + 5;                return result;          }

Here‘s what happens at the very top of the Stack.  Keep in mind that what we are looking at is placed on top of many other items already living in the Stack:

Once we start executing the method, the method‘s parameters are placed on the Stack (we‘ll talk more about passing parameters later).

NOTE : the method does not live on the stack and is illustrated just for reference.



Next, control (the thread executing the method) is passed to the instructions to the AddFive() method which lives in our type‘s method table, a JIT compilation is performed if this is the first time we are hitting the method.



As the method executes, we need some memory for the "result" variable and it is allocated on the Stack.



The method finishes execution and our result is returned.



And all memory allocated on the Stack is cleaned up by moving a pointer to the available memory address where AddFive() started and we go down to the previous method on the stack (not seen here).



In this example, our "result" variable is placed on the stack.  As a matter of fact, every time a Value Type is declared within the body of a method, it will be placed on the stack.

Now, Value Types are also sometimes placed on the Heap.  Remember the rule, Value Types always go where they were declared?  Well, if a Value Type is declared outside of a method, but inside a Reference Type then it will be placed within the Reference Type on the Heap.

Here‘s another example.

If we have the following MyInt class (which is a Reference Type because it is a class):

public class MyInt          {                       public int MyValue;          }

and the following method is executing:

public MyInt AddFive(int pValue)          {                MyInt result = new MyInt();                result.MyValue = pValue + 5;                return result;          }

Then just as before, the thread starts executing the method and its parameters are placed on sthe thread‘s stack.



Now is when it gets interesting.

Because MyInt is a Reference Type, it is placed on the Heap and referenced by a Pointer on the Stack.



After AddFive() is finished executing (like in the first example), and we are cleaning up...



we‘re left with an orphaned MyInt in the Heap (there is no longer anyone in the Stack standing around pointing to MyInt)!



This is where the Garbage Collection (GC) comes into play.  Once our program reaches a certain memory threshold and we need more Heap space, our GC will kick off.  The GC will stop all running threads (a FULL STOP), find all objects in the Heap that are not being accessed by the main program and delete them.  The GC will then reorganize all the objects left in the Heap to make space and adjust all the Pointers to these objects in both the Stack and the Heap.  As you can imagine, this can be quite expensive in terms of performance, so now you can see why it can be important to pay attention to what‘s in the Stack and Heap when trying to write high-performance code.

Ok, that‘s great, but how does it really affect me?

Good question.

When we are using Reference Types, we‘re dealing with Pointers to the type, not the thing itself.  When we‘re using Value Types, we‘re using the thing itself.  Clear as mud, right?

Again, this is best described by example.

If we execute the following method:

public int ReturnValue()          {                int x = new int();                x = 3;                int y = new int();                y = x;                      y = 4;                          return x;          }

We‘ll get the value 3.  Simple enough, right?

However, if we are using the MyInt class from before:

public class MyInt          {                public int MyValue;          }

and we are executing the following method:

public int ReturnValue2()          {                MyInt x = new MyInt();                x.MyValue = 3;                MyInt y = new MyInt();                y = x;                                 y.MyValue = 4;                              return x.MyValue;          }

What do we get?    4!

Why?...  How does x.MyValue get to be 4? Take a look at what we‘re doing and see if it makes sense:

In the first example everything goes as planned:

public int ReturnValue()          {                int x = 3;                int y = x;                    y = 4;                return x;          }



In the next example, we don‘t get "3" because both variables "x" and "y" point to the same object in the Heap.

public int ReturnValue2()          {                MyInt x;                x.MyValue = 3;                MyInt y;                y = x;                                y.MyValue = 4;                return x.MyValue;          }



Hopefully this gives you a better understanding of a basic difference between Value Type and Reference Type variables in C# and a basic understanding of what a Pointer is and when it is used.  In the next part of this series, we‘ll get further into memory management and specifically talk about method parameters.

For now...

Happy coding.