在《如何计算一个实例占用多少内存?》中我们知道一个值类型或者引用类型的实例在内存中占多少字节。如果我们知道这段连续的字节序列的初始地址,我们就能够将代表该实例的字节内容读取出来。在接下来的内容中,我们将利用一个简单的方法输出指定实例的字节序列,并此次分析值类型和引用类型实例在内存的布局。

一、读取实例在内存中的字节
二、查看值类型和引用类型实例的内存字节
三、存储方法表地址
四、Object Header的内存布局
五、存储“瘦锁”
六、存储哈希码
七、存储SyncBlock Index

一、读取实例在内存中的字节

如下所示的PrintBytes<T>会将指定实例在内存中的字节输出到控制台上。如代码片段所示,我们先调用《如何计算一个实例占用多少内存?》中定义了SizeCalculator将承载实例内容的字节数计算出来,并创建对应长度的字节数组来存放读取的字节。如果指定的变量value是一个结构体(值类型),意味着变量会直接指向结构体的首字节。在这种情况下,我们只需要将该变量的引用转换成指针(void*),然后将其转换成IntPtr对象,并作为起始地址调用Marshal的Copy方法将指定数量的字节拷贝到创建的字节数组就可以了。

public static class BytesPrinter
{
    public unsafe static void PrintBytes<T>(T value)
    {
        var size = SizeCalculator.Instance.SizeOf(() => value);
        var bytes = new byte[size];

        var pointer = Unsafe.AsPointer(ref value);
        IntPtr head = typeof(T).IsValueType ? new IntPtr(pointer) : *(IntPtr*)pointer - IntPtr.Size;
        Marshal.Copy(head, bytes, 0, size);
        Console.WriteLine($"[{size}]{BitConverter.ToString(bytes)}");
    }

    public static string AsString(this IntPtr ptr) => BitConverter.ToString(BitConverter.GetBytes(ptr.ToInt64()));
}

对于引用类型,整个过程就要复杂一些。此时指定的变量value指向的是目标对象的地址,所以在将此变量引用转换成void*指针后,还需要将其转换成IntPtr*指针,并最终将指针的内容(也就是目标对象的地址)解析出来。由于变量指向的地址并非目标实例映射内存字节的首地址,仅仅是存储方法表地址的地方,所以还需要向前移动一个身位(IntPtr.Size)才是实例所在内存片段的首地址。在将所需字节拷贝到创建的字节数组之后,我们将其格式化成字符串输出到控制台上。另一个AsString扩展方法会将指定IntPtr对象表示的内存地址输出到控制台上,我们会在后续的演示中使用到它。

二、查看值类型和引用类型实例的内存字节

在如下的代码片段中,我们定义的结构体FoobarStructure和类FoobarClass具有两个字段Foo和Bar,对应类型分别是Byte和Int32。我们分别创建了它们的实例,并将这两个字段设置成255(0xFF)和65535(0xFFFF)。我们将它们作为参数调用了上面定义的PrintBytes方法。

BytesPrinter.PrintBytes(new FoobarStructure(255, 65535));
BytesPrinter.PrintBytes(new FoobarClass(255, 65535));

public struct FoobarStructure
{
    public byte Foo;
    public int Bar;

    public FoobarStructure(byte foo, int bar)
    {
        Foo = foo;
        Bar = bar;
    }
}

public class FoobarClass
{
    public byte Foo;
    public int Bar;

    public FoobarClass(byte foo, int bar)
    {
        Foo = foo;
        Bar = bar;
    }

}

程序执行后会将指定的FoobarStructure和FoobarClass实际对应的字节输出控制台上。为了更好地理解该字节序列每一部分的内容,我特意按照如下的方式添加了方括号对它们进行了分割。从下面的内容可以看出,虽然Byte和Int32对应的字节数分别为1和4,但是FoobarStructure这个结构体的字节数却是8,三个空白字节(红色标记)是为了内存对齐额外添加的“留白(Padding,红色标注)”。从字节的内容还可以看出,内存中体现的字段顺序默认与它们在结构体中定义的顺序是一致的(Foo:FF;Bar:FF-FF-00-00)。顺便提一下,基元类型在内存中是按照“小端序”存储的。

[8][FF-00-00-00]-[FF-FF-00-00]

[24][00-00-00-00-00-00-00-00]-[38-39-78-B3-FD-7F-00-00]-[FF-FF-00-00-FF-00-00-00]

FoobarClass实例在内存中的字节数要多很多,变成了24。第一组8字节是代表ObjectHeader(包含4字节用于内存对齐的空字节),第2组8字节代表FoobarClass类型的方法表的内存地址。两个字段的内容体现在最后一组8字节中,可以看出它们内容与FoobarStructure不一样,这是因为在默认的情况下,结构体采用Sequential(与定义一致),而类则采用Auto,其目的是为了满足内存对其规则的情况下对字段进行重新排序,以节省内存空间。在这里Bar字段(FF-FF-00-00)被放在Foo字段(FF)的前面。由于24是引用类型实例在内存中的最小字节数(针对x64架构),字段重排针对内存的“压缩”没有体现出来。

三、存储方法表地址

.NET运行时中针对“类型”的描述信息几乎都来自于方法表这个内部的数据结构。引用类型实例在内存中的第二部分内容(ObjectHeader之后)存放的就是对应方法表的地址,实例和类型就是通过这种方式关联起来的。在C#中,我们也可以利用表示“类型句柄(Type Handle)”的RuntimeTypeHandle对象得到对应类型方法表的地址。在如下所示的代码片段中,我们在输出FoobarClass对象的内存字节序列后,我们进一步获得了FoobarClass类型的TypeHandle对象,该对象的Value属性返回的就是方法表地址。我们调用上面定义的AsString扩展方法将其转换成格式化字符串后输出到控制台上。

BytesPrinter.PrintBytes(new FoobarClass(255, 65535));
Console.WriteLine("[TypeHandle]{0}",typeof(FoobarClass).TypeHandle.Value.AsString());

从如下所示的输出结果可以看出,实例内存字节承载的和TypeHandle提供的方法表地址是一致的。

[24]00-00-00-00-00-00-00-00-38-37-78-B3-FD-7F-00-00-FF-FF-00-00-FF-00-00-00

[TypeHandle]38-37-78-B3-FD-7F-00-00

四、Object Header的内存布局

我看到一些文档将Object Header命名为SyncBlock Index/Number,这种命名不能算错,但至少没有完整地体现Object Header的作用以及存储方式。当我们对某个对象加锁的时候,系统会使用一个名为SyncBlock的内部数据结果与之关联,SyncBlock中会包含当前线程ID和递归等级等信息。这样的SyncBlock被保存在一个SyncBlock Table中,它在这个表中的索引会存储在Object Header。

clip_image001

实际上SyncBlock Index只体现了Object Header只体现了Object Header的一种使用场景而已。这种将SyncBlock Index存储在Object Header中实现的锁被称为 “胖锁(Fat Lock)” ,既然有胖锁,自然就有瘦锁(Thin Lock),瘦锁直接将同步信息存储在Object Header中。由于不需要访问SyncBlock Table,瘦锁的性能要高很多。除了用于存储同步信息,Object Header还可以用来缓存对象的Hash码。上图体现了Object Header典型的三种存储场景:

  • 瘦锁:使用Object Header的低27位存储当前AppDomain索引(16-26)、锁的递归等级(10-15)和线程ID(0-9);
  • 哈希码:使用Object Header的低26位存储对象的哈希码;
  • SyncBlock Index: 使用Object Header的低26位存储关联的SyncBlock 在SyncBlock Table的索引。

为了确定Object Header存储的内容,它的高5位被预留了下来,它们分别表示:

  • 27-BIT_SBLK_IS_HASH_OR_SYNCBLKINDEX:确定存储的内容是否是哈希或者SyncBlock Index;
  • 28-BIT_SBLK_SPIN_LOCK:CLR使用它以原子操作的方式修改Object Header的内容;
  • 29- BIT_SBLK_GC_RESERVE :GC在执行过程中用于标记对象是否被固定(pined)
  • 30- BIT_SBLK_FINALIZER_RUN:GC用于确定对象的析构函数是否被调用;
  • 31- BIT_SBLK_AGILE_IN_PROGRESS:在debug build下被用来确定两个跨AppDomain应用的对象之间是否存在死循环。

对于上图中的第2/3中存储场景下,由于BIT_SBLK_IS_HASH_OR_SYNCBLKINDEX只能确定承载的内容是否是哈希码还是SyncBlock Index,我们还得使用第26位(0-base)作进一步区分。这个比特被称为BIT_SBLK_IS_HASHCODE,顾名思义,它表示承载得内容是否是对象得哈希码。

五、存储“瘦锁”

在了解了Object Header的字节布局后,我们利用我们定义的方法将对象的Object Header的内容读取出来,看看它的内容是否与描述的一致。我们先来看看基于“瘦锁”的存储方式。

await Task.Yield();
PrintThreadId();
var foobar = new Foobar();
lock (foobar)
{
    BytesPrinter.PrintBytes(foobar);
    lock (foobar)
    {
        BytesPrinter.PrintBytes(foobar);
        lock (foobar)
        {
            BytesPrinter.PrintBytes(foobar);
            Debugger.Break();
        }
    }
}

static void PrintThreadId()
{
    var bytes = BitConverter.GetBytes(Environment.CurrentManagedThreadId);
    Console.WriteLine($"Thread Id: {BitConverter.ToString(bytes)}");
}
public class Foobar{}

在如下所示的演示程序中,我们定义了一个“空”的类Foobar。await Task.Yield()之后的操作将以异步的方式执行,为了确定Object Header中是否包含当前线程的ID,我们将线程ID以16进制的形式输出到控制台上。然后我们创建了一个Foobar对象,然后嵌套的方式锁定它,并在锁定上下文中将改对象的内存字节输出来。

Thread Id: 06-00-00-00

[24]00-00-00-00-06-00-00-00-10-02-66-4C-FA-7F-00-00-00-00-00-00-00-00-00-00

[24]00-00-00-00-06-04-00-00-10-02-66-4C-FA-7F-00-00-00-00-00-00-00-00-00-00

[24]00-00-00-00-06-08-00-00-10-02-66-4C-FA-7F-00-00-00-00-00-00-00-00-00-00

如下所示的程序运行后在控制台上的输出,我们可以看到当前线程ID是6(采用小端字节序)。按照我们上面介绍的内存布局,0-9这10位用来表示线程,由于三次输出都是在同一个线程中进行的,所以这10位比特(红色)是一致的(0000000110),对应的值位6,刚好是当前线程ID。10-15这6位(紫色)表示递归等级,解析出来值分别是0,1和2,与我们的程序正好吻合。

[0000 0][000 0000 0000] [0000 00][00 0000 0110]
[0000 0][000 0000 0000] [0000 01][00 0000 0110]
[0000 0][000 0000 0000] [0000 10][00 0000 0110]

我们在最里层的lock语句中调用了Debugger的Break方法,所以程序会在这里停下来。如果此时我们将当前进程的Dump抓下来,通过执行dumpheap -thinlock命令会将所有“瘦锁”列出来,从输出的嵌套等级(2)和dumpobj的显式结果可以看出这个瘦锁就是Foobar对象。

clip_image003

六、存储哈希码

我们接下来采用类似的方式演示Object Header针对哈希码的缓存。如下面的代码片段所示,我们创建了上面定义的Foobar对象,在将其内存字节打印出来之前,我们先将其GetHashCode方法返回的哈希码打印来。

var foobar = new Foobar();
var hashCode = foobar.GetHashCode();
PrintHashCode(hashCode);
BytesPrinter.PrintBytes(foobar);
static void PrintHashCode(int hashCode)
{
    var bytes = BitConverter.GetBytes(hashCode);
    Console.WriteLine($"Hash Code: {BitConverter.ToString(bytes)}");
}

从下面的输出可以看出整个Object Header的内容应该和哈希码是有关系,因为至少可以看到前面3个字节内容(9D-0D-3C)的完全一致的,但是为什么最后一个字节不同呢?

Hash Code: 9D-0D-3C-03

[24]00-00-00-00-9D-0D-3C-0F-10-86-78-E0-FA-7F-00-00-00-00-00-00-00-00-00-00

再次回到上面的描述,在第二种用于存储哈希码的场景中,Object Header利用低26位来存储哈希,所以我们按照如下的方式将其低26位提取出来后就会发现对应的值就是哈希码。在看前面的6位,BIT_SBLK_IS_HASH_OR_SYNCBLKINDEXBIT_SBLK_IS_HASHCODE位均为1,这样就可以确定后26位存储的就是哈希码了。

0F 3C 0D 9D

00001111 00111100 00001101 10011101

00000011 00111100 00001101 10011101

03 3C 0D 9D

由于Object类型的GetHashCode方法的返回类型为Int32,如果我们重写了这个方法,就可能导致ObjectHeader无法使用26位来存放哈希值。比如我们将重写了演示实例所用的Foobar类型,让重写的GetHashCode返回Int32.MaxValue。

public class Foobar
{
    public override int GetHashCode() => int.MaxValue;
}

很显然Foobar对象的哈希码就无法存储在Object Header中,如下的输出体现了这一点。其实不管计算出来的哈希码能否使用26个比特来表示,只要类型重写了GetHashCode方法且没有直接返回base.GetHashCode(),使用Object Header来缓存哈希码的策略就会失效。这一点告诉我们:当我们需要试图去重写某个类的GetHashCode方法,先考虑一下这个类型是否应该定义成结构体。

Hash Code: FF-FF-FF-7F

[24]00-00-00-00-00-00-00-00-70-27-7A-E0-FA-7F-00-00-00-00-00-00-00-00-00-00

七、存储SyncBlock Index

我们使用如下的代码来演示Object Header针对SyncBlock Index的存储。在将Foobar对象创建出来后,我们先调用其GetHashCode方法,并在针对该对象的lock上下文中完成针对内存字节的输出。

var foobar = new Foobar();
foobar.GetHashCode();
lock (foobar)
{
    BytesPrinter.PrintBytes(foobar);
    Debugger.Break();
}
public class Foobar{}

如下所示的是程序运行后的输出结果,红色标注的正是存储SyncBlock Index的Object Header的内容。

[24]00-00-00-00-0F-00-00-08-20-BD-87-E0-FA-7F-00-00-00-00-00-00-00-00-00-00

我们按照与上面一样的方式将这4个字节转换成二进制,可以确定BIT_SBLK_IS_HASH_OR_SYNCBLKINDEX和BIT_SBLK_IS_HASHCODE位分别为1和0,所以可以确定低26位存储的就是SyncBlock Index,对应的值位15(0b111)。

08 00 00 0F

00001000 00000000 00000000 00001111

我们在lock上下文中同样调用了Debugger的Break方法,所以程序会在这里停下来。如果此时我们将当前进程的Dump抓下来,通过执行syncblk将正在被使用的SyncBlock显式出来,唯一的那个的Index正是15

clip_image005

内容来源于网络如有侵权请私信删除

文章来源: 博客园

原文链接: https://www.cnblogs.com/artech/p/17456172.html

你还没有登录,请先登录注册
  • 还没有人评论,欢迎说说您的想法!