读懂IL代码就这么简单(三)完结篇

一前言

写了两篇关于IL指令相关的文章，分别把值类型与引用类型在堆与栈上的操作区别详细的写了一遍
这第三篇也是最后一篇，之所以到第三篇就结束了，是因为以我现在的层次，能理解到的都写完了，而且个人认为，重要的地方都差不多
写到了，
最后一篇决定把之前的内容全部整合起做一个综合的例子，然后简单的解释下IL指令的含义，及在内存中的变化
如果你没有看前两篇请狂点这里

读懂IL代码就这么简单 (一)

读懂IL代码就这么简单(二)

IL指令大全：IL指令详解

IL反编译工具： ILDasm

注：因本人水平有限，难免有理解错误之处，如有发现，望及时指出，我会立马更正。

二 IL指令详解 (基本介绍)

这次把类委托方法字段都集合起来，这样的环境就与实际的项目比较接近了，也算接地气了

先看C#代码

 1     public delegate void MyDele(string name);

 2     class Program

 3     {

 4         static void Main(string[] args)

 5         {

 6

 7             UserInfo userInfo = new UserInfo();

 8

 9             PeopleStruct peopleStruct = new PeopleStruct();

10

11             //定义委托

12             MyDele myDele = userInfo.PrintName;

13             //调用委托

14             myDele("Delegate");

15

16             userInfo.PrintName("PrintName");

17             userInfo.PrintField();

18             //静态方法

19             UserInfo.ContactStr("UserInfo", "ContactStr");

20             //结构的方法

21             peopleStruct.PrintInfo("Color is Yellow");

22

23             //静态类中的静态方法

24             StaticUserInfo.PrintName("Static Class Static Method");

25

26             Console.Read();

27         }

28     }

29

30     internal class UserInfo

31     {

32         public string Name = "UserInfo Field";

33

34         public void PrintName(string name)

35         {

36             Console.WriteLine(name);

37         }

38

39         public void PrintField()

40         {

41             Console.WriteLine(Name);

42         }

43

44         public static void ContactStr(string Str, string Str2)

45         {

46             Console.WriteLine(Str + Str2);

47         }

48

49     }

50

51     struct PeopleStruct

52     {

53

54         public void PrintInfo(string color)

55         {

56             Console.WriteLine(color);

57         }

58

59     }

60

61     static class StaticUserInfo

62     {

63         public static void PrintName(string name)

64         {

65             Console.WriteLine(name);

66         }

67     }

IL 代码

call可以调用静态方法，实例方法和虚方法

callvirt只能调用实例方法和虚方法，不能调用静态方法

 1 .method private hidebysig static void  Main(string[] args) cil managed

 2 {

 3   .entrypoint

 4   // Code size       106 (0x6a)

 5   .maxstack  2

 6   .locals init (class ILDeom3.UserInfo V_0, //只定义变量并不做任何初始化操作

 7            valuetype ILDeom3.PeopleStruct V_1,

 8            class ILDeom3.MyDele V_2)

 9   IL_0000:  nop

10       //创建一个值类型的新对象或新实例，并将对象引用推送到计算堆栈上

11   IL_0001:  newobj     instance void ILDeom3.UserInfo::.ctor()

12       //把栈中顶部的元素弹出(UserInfo 的实例)并赋值给局部变量表中第0个位置的元素(V_0)

13   IL_0006:  stloc.0

14       //将位于特定索引处的局部变量的 "地址" 加载到计算堆栈上(将指向结构的地址压入栈中)

15   IL_0007:  ldloca.s   V_1

16       //初始化结构中的属性

17   IL_0009:  initobj    ILDeom3.PeopleStruct

18       //将局部变量列表中第0个位置(V_0 UerInfo的实例地址)的值压入栈中

19   IL_000f:  ldloc.0

20       //将指向实现特定方法的本机代码的非托管指针（native int 类型）推送到计算堆栈上。

21       //也就是指的将方法指针压入栈中

22   IL_0010:  ldftn      instance void ILDeom3.UserInfo::PrintName(string)

23      //创建委托的实例并压入栈中

24      //这一步会调用委托的构造器，这个构造器需要两个参数，一个对象引用，就是IL_000f:  ldloc.0压入的UserInfo的实例，一个方法的地址。

25   IL_0016:  newobj     instance void ILDeom3.MyDele::.ctor(object,native int)

26       //弹出栈中值(委托的实例)保存到局部变量表第2个位置(V_2)

27   IL_001b:  stloc.2

28       //获取局部变量列表中第2个位置上的值上一步保存的值(委托实例）,并压入栈中

29   IL_001c:  ldloc.2

30       //加载字符串

31   IL_001d:  ldstr      "Delegate"

32       //调用绑定给委托的PrintName方法

33   IL_0022:  callvirt   instance void ILDeom3.MyDele::Invoke(string)

34   IL_0027:  nop

35       //获取局部变量列表中第0个位置上的值(UserInfo的实例)

36   IL_0028:  ldloc.0

37   IL_0029:  ldstr      "PrintName"

38      //调用PrintName方法

39   IL_002e:  callvirt   instance void ILDeom3.UserInfo::PrintName(string)

40   IL_0033:  nop

41       //获取局部变量列表中第0个位置上的值(UserInfo的实例)

42   IL_0034:  ldloc.0

43       //调用PrintField方法

44   IL_0035:  callvirt   instance void ILDeom3.UserInfo::PrintField()

45   IL_003a:  nop

46   IL_003b:  ldstr      "UserInfo"

47   IL_0040:  ldstr      "ContactStr"

48       //因为ContactStr是静态方法所以不需要先加载实例可以直接调用

49   IL_0045:  call       void ILDeom3.UserInfo::ContactStr(string,

50                                                          string)

51   IL_004a:  nop

52       //将位于特定索引处的局部变量的 "地址" 加载到计算堆栈上 （将指向结构的地址压入栈中）

53   IL_004b:  ldloca.s   V_1

54   IL_004d:  ldstr      "Color is Yellow"

55       //调用结构中的PrintInfo方法

56   IL_0052:  call       instance void ILDeom3.PeopleStruct::PrintInfo(string)

57   IL_0057:  nop

58   IL_0058:  ldstr      "Static Class Static Method"

59   IL_005d:  call       void ILDeom3.StaticUserInfo::PrintName(string)

60   IL_0062:  nop

61   IL_0063:  call       int32 [mscorlib]System.Console::Read()

62   IL_0068:  pop

63   IL_0069:  ret

64 } // end of method Program::Main

相信有注释，大家应该都是能够看懂的，IL其实并不难，也并不算底层，只是把C#编译成了中间语言，并非机器语言，CPU照样还是读不懂，

三 IL指令详解 (深入了解)

因这次IL指令，有点长，要画图确实有点扛不住，所以只画重要的地方，还望见谅.

另外跟园子里的 @冰麟轻武探讨了跟IL相关的三个内存块 Managed Heap ,Evaluation Stack,Call Stack 了解到了很多之前不明白的知识点，

也纠正了自己以前的一些误区，最后一致认可我们自己的讨论结果，讨论结果如下，

1 Managed Heap(托管堆) 程序运行时会动态的在其中开辟空间来存储变量的值，如new class 时，回收由GC 根据代龄，和可达对象，来回收相应的内存资源。整个程序共用一个ManagedHeap

2 Evaluation Stack(计算栈)：每个线程都有一个独立的评估栈，用于程序相关的运算，

3 Call Stack(调用栈)：讨论的重点就在这里，之前认为Call Stack并不是一个栈，而是一个局部变量列表，用于存放方法的参数，可是我一直有疑问就是值类型应该是存在栈中的，如果Call Stack是个栈，那取值时Call Stack并没有按FILO的原则来，那如果 Call Stack不是个栈那值类型的值是存在哪里的，然后我与@冰麟轻武就这一问题，讨论起来了

　　先看官方对Call Stack的解释：这是由.NET CLR在执行时自动管理的存储单元，每个Thread都有自己专门的Call Stack。每呼叫一次method，就会使得Call Stack上多一个Record Frame；方法执行完毕之后，此Record Frame会被丢弃。重点就在红色这一句中的 Record Frame又是个什么东西他里边有什么东西？然后开始各种假设，最终我们认为这一种理论是比较靠谱一点的如下：

　　Call Stack本身就是一个栈，每调用一个方法时就会在栈顶部加载一个Record Frame，这个Record Frame里包含了方法所需要的参数(Params)，返回地址（Return Address）和区域变量(Local Variable)，当调用的方法结束时，就自动会把这个Record Frame从栈顶弹出。如此一来，我之前的疑问就可以得到相应的解释了

　　值类型是存在栈中的，当调用方法里会把方法需要的值重栈中取出，然后在栈中创建一个Record Frame并把赋值给Record Frame中的参数，在这个Record Frame中取数据并不是按FILO原则来的，而可以按索引，也可以按地址对应IL指令 Ldloc stLoc 等取值与赋值都是针对的Record Frame 。而且我们认为Call Stack是对线程栈的一个统称。

上图

下面图解一下实例化一个类，并调用类中的方法在内存中是如何变化的

.locals init (class ILDeom3.UserInfo V_0,valuetype ILDeom3.PeopleStruct V_1,class ILDeom3.MyDele V_2)

IL_0001: newobj instance void ILDeom3.UserInfo::.ctor()

IL_0006: stloc.0

IL_0028: ldloc.0

IL_0029: ldstr "PrintName"
IL_002e: callvirt instance void ILDeom3.UserInfo::PrintName(string)

四总结

　　IL系列终于写完了，也算给自己一个交代了，写文章真的很花时间，就以我这三篇为例，光只是写和画图都有花十几个小时，而且如果是晚上写一般都会超过12点才能完成，更不用说前期的自己学习所用的时间，

但是我觉得真的很值得，充分的把自己的业余时间利用起来了，对于IL也有了一个相对深入的了解，

在此要感谢园子里朋友的支持，也感谢 @冰麟轻武对我的指点，更要感谢dudu能建立博客园这么好的一个环境。

内存池的原理及实现

在软件开发中，有些对象使用非常频繁，那么我们可以预先在堆中实例化一些对象，我们把维护这些对象的结构叫“内存池”。在需要用的时候，直接从内存池中拿，而不用从新实例化，在要销毁的时候，不是直接free/delete，而是返还给内存池。

把那些常用的对象存在内存池中，就不用频繁的分配/回收内存，可以相对减少内存碎片，更重要的是实例化这样的对象更快，回收也更快。当内存池中的对象不够用的时候就扩容。

我的内存池实现如下：

#pragma once

#include <assert.h>

template<typename T>

struct ProxyT

{

    ProxyT():next(NULL){}

    T data;

    ProxyT* next;

};

template<typename T>

class MemoryPool

{

public:

    static void* New()

    {

        if(next==NULL)

        {

            Alloc();

        }

        assert(next!=NULL);

        ProxyT<T>* cur=next;

        next=next->next;

        return cur;

    }

    static void Delete(void* ptr)

    {

        ProxyT<T>* cur=static_cast<ProxyT<T>*>(ptr);

        cur->next=next;

        next=cur;

    }

#ifdef CanFree

    static void Clear()

    {

        ProxyT<T>* proxy=NULL;

        while(next!=NULL)

        {

            proxy=next->next;

            delete next;

            next=proxy->next;

        }

        next=NULL;

    }

#endif

private:

    static void Alloc(size_t size=16)

    {

        if(next==NULL)

        {

        #ifdef CanFree

            ProxyT<T>* tmpProxy=new ProxyT<T>();

            next=tmpProxy;

            for(int i=1;i<size;i++)

            {

                tmpProxy->next=new ProxyT<T>();

                tmpProxy=tmpProxy->next;

            }

        #else

            ProxyT<T>* memory=(ProxyT<T>*)malloc(size*sizeof(ProxyT<T>));

            ProxyT<T>* tmpProxy=new (memory) ProxyT<T>();

            next=tmpProxy;

            for (size_t i=1;i<size;i++)

            {

                tmpProxy->next=new (memory+i) ProxyT<T>();

                tmpProxy=tmpProxy->next;

            }

        #endif

        }

    }

    static ProxyT<T>* next;

    MemoryPool<T>();

    MemoryPool<T>(const MemoryPool<T>&);

};

template<typename T> ProxyT<T>* MemoryPool<T>::next=NULL; 

#define NewAndDelete(className)             \

static void* operator new(size_t size)      \

{                                           \

    return MemoryPool<className>::New();    \

}                                           \

static void operator delete(void* ptr)      \

{                                           \

    MemoryPool<className>::Delete(ptr);     \

}

测试代码如下：

#include "stdafx.h"

#define CanFree

#include "MemoryPool.h"

struct A

{

    int i;

    NewAndDelete(A)

};

int _tmain(int argc, _TCHAR* argv[])

{   

    {

        vector<A*> vect;

        for(int i=0;i<16;i++)

        {

            A* a=new A();

            a->i=i;

            vect.push_back(a);

        }

        for(int i=0;i<vect.size();i++)

        {

            cout<<vect[i]->i<<endl;

        }

        for(int i=vect.size()-1;i>=0;i--)

        {

            delete vect[i];

        }

        vect.clear();

        MemoryPool<A>::Clear();

    }

    system("pause");

    return 0;

}

运行结果如下图：

不到100行代码，有两个public方法New和Delete；还有一个Clear方法，这个方法的存在取决于是否定义了宏CanFree，如果定义了这个宏，那么对象是一个个的实例化，在调用Clear的时候可以一个个的回收，如果没有定义，那么是一次分配一块较大的内存，然后在这块内存上实例化多个对象，但没有实现回收这块内存的方法，如果要回收这样的大块内存块，就必须将这些内存块的首地址存起来，我这里没有存起来，而且还要标记对象是否使用，那么Proxy<T>还要加一个字段表示是否使用，在回收的时候还要判断所有对象是否没有使用，只有都没使用才能回收，妹的，为了回收弄得这么麻烦，话说你为什么要回收内存池呢，于是就没有实现回收的方法。整个内存池其实就是一个单链表，表头指向第一个没有使用节点，我们可以把这个单链表想象成一段链条，调用方法New就是从链条的一端（单链表表头）取走一节点，调用方法Delete就是在链条的一端（单链表表头）前面插入一个节点，新插入的节点就是链表的表头，这样New和Delete的时间复杂度都是O(1)，那叫一个快。

所有要使用内存池的对象，只需要在这个对象中引入宏NewAndDelete，这个宏其实就是重写对象的new和delete方法，让对象的创建和回收都通过内存池来实现，所有用内存池实现的对象使用起来和别的对象基本上是一样，唯一的一个问题就是内存池对象对象不是线程安全的，在多线程编程中，创建一个对象时必须枷锁。如果在New和Delete的实现中都加个锁，我又觉得他太影响性能，毕竟很多时候是不需要枷锁，有些对象可能有不用于多线程，对于这个问题，求高手指点！

巴特西

IL代码完结篇

读懂IL代码就这么简单(三)完结篇

一前言

二 IL指令详解 (基本介绍)

三 IL指令详解 (深入了解)

四总结

内存池的原理及实现

最新文章

热门文章

巴特西

IL代码完结篇

读懂IL代码就这么简单(三)完结篇

一 前言

二 IL指令详解 (基本介绍)

三 IL指令详解 (深入了解)

四 总结

内存池的原理及实现

最新文章

热门文章

一前言

四总结