C# 内存分配&&垃圾回收解析

在学习C#的过程中,大家一定会听说过一些CLR、JIT、LR、什么堆栈分配、内存释放的东西,谈到大家对这些元素的理解,多数都是这些是操作系统里面的东西,值类型、引用类型会和堆栈相关,但是在问到这些提到的名称具体是做什么的,或者扮演什么样的角色的时候,大家好像也能讲出点什么,但是也讲得模模糊糊,虽然这些都是一些理论知识,而且在开发的过程中可能也用不到,但还是能尽量多了解一下比较好,今天,笔者就谈一谈自己对这些元素的理解


有说的不准确或者不正确的地方欢迎留言指正


在日常生活中,如果要和其他语种的人交流,而且自己还不懂得情况下我们会怎么办?首先会想到找翻译软件,首先把自己说的话输入到翻译软件中,软件会根据输入文字的语法转到另一种歪果仁说的语言,其中主要步骤会经过检测—–校验—–输出。

其实在计算机的世界中,代码编译成0101这种形式的机器码也是大概如此,首先我们会在编译器中(例如:visual studio 2017)根据逻辑的需求编写C#代码,这个可以理解为我们说的母语,然后经过计算机的翻译编译成机器能听懂的语言(机器码),而下图中显示的 【metadata】【IL】【CLR】【JIT】就是在上面举例中提到翻译,翻译过程中【检测】—-【校验】—-【输出】需要这些元素的参与

缩写的全称:

  • CTS是通用类型系统(Common Type System)
  • CLR是公共语言运行时(Common language runtime)
  • CLS是公共语言定义(Common Language Specification)
参考链接:https://blog.csdn.net/huang_xw/article/details/8578162
参考链接:https://docs.microsoft.com/zh-cn/dotnet/standard/common-type-system
代码编译后会形成DLL或者EXE文件,在这些文件中含有【metadata】与【IL】两种元素,下面我们逐一说明这两个元素的用途

metadata

通俗的讲:metadata就是一个档案库,一份清单,一个说明里面含有什么东西的列表。他里面详细的说明这个DLL或者EXE文件中都有什么类、函数、属性、字段、版本号等等,而且经常用到的特性(Attribute)的信息也在里面,不熟悉【特性】的小伙伴请看Unity C#基础之 特性,一个灵活的小工具。(也就是举例中需要翻译的是什么语言,多少个字,含有什么标点符号,在什么位置等等这些信息)

IL(中间语言)

IL又称:中间语言,他在翻译过程中是起到牵线搭桥的作用,类似于我能听懂(编译器),歪果仁也能听懂(计算机)的语言。如果想查看IL可以使用ILSpy反编译工具查看

上面提到的【metadata】【IL】仅仅是翻译前的准备工作,下面才是开始正式的【检测】—-【校验】—-【输出】

首先说下CLR

说道CLR他就厉害了,正是因为有了CLR这种运行环境,才能让不同语言编译的IL得以在不同的操作系统中运行,例如32位、64位的操作系统,而且不同的操作系统里面额CLR也是不一样的。

然后是JIT

基于上面提到的CLR环境,JIT根据不同的CLR将相同的IL依据清单(metadata)和dll或exe,开始正式的【检测】—-【校验】—-【输出】生成0101这种的机器码,JIT编译的时候会检测是否编译过机器码。如果编译过拿过来复用

上面说到的整体流程可以看一下托管执行过程


接下来说一下.NET 中的内存管理和垃圾回收

因为下面所提到的都是总结性结论,参考地址MSDN官方文档
我们结合代码来说一下堆栈的分配
    public struct ValuePoint// : System.ValueType  结构不能有父类,因为隐式继承了ValueType(通过反编译工具可查看)
    {
        public int x;
        public ValuePoint(int x)
        {
            this.x = x;
        }
    }

        public void Test()
        {
            //内存分配:线程栈   
            {//值类型分配在线程栈,变量和值都是在线程栈
                ValuePoint valuePoint;//先声明变量,没有初始化  但是我可以正常赋值  跟类不同
                valuePoint.x = 123;

                ValuePoint point = new ValuePoint();
                Console.WriteLine(valuePoint.x);
            }
        }
声明的valuePoint和他对应的x都是在栈上面的

    public class ReferencePoint
    {
        public int x;
        public ReferencePoint(int x)
        {
            this.x = x;
        }
    }

        public void Test()
        {
            ReferencePoint referencePoint = new ReferencePoint(123);
        }
  • 引用类型分布在堆上面 变量是在栈上的(保存的地址),值是在堆上面
  • new的时候去堆开辟内存,分配一个地址
  • 调用构造函数(因为在构造函数里可以使用this),才执行构造函数把引用传给变量

    /// <summary>
    /// class  引用类型
    /// </summary>
    public class ReferenceTypeClass
    {
        private int _valueTypeField;//堆:因为对象都在堆里,对象里面的属性也在堆里
        public ReferenceTypeClass()
        {
            _valueTypeField = 0;
        }
        public void Method()
        {
            int valueTypeLocalVariable = 0;//栈:全新的局部变量,线程栈来调用方法,然后分配内存
        }
    }

        public void Test()
        {
            ReferenceTypeClass referenceTypeClassInstance = new ReferenceTypeClass();
            referenceTypeClassInstance.Method();
        }
  • _valueTypeField是在堆上面,因为对象都在堆里,对象里面的属性也在堆里
  • valueTypeLocalVariable是在栈上面,因为全新的局部变量,线程栈来调用方法,然后分配内存

    /// <summary>
    /// 值类型
    /// </summary>
    public struct ValueTypeStruct
    {
        private object _referenceTypeField;// 这个对象的变量在栈上,值在堆上
        public ValueTypeStruct(int x)
        {
            _referenceTypeField = new object();
        }
        public void Method()
        {
            object referenceTypeLocalVariable = new object();//这个对象的变量在栈上,值在堆上
        }
    }

        public void Test()
        {
            ValueTypeStruct valueTypeStructInstance = new ValueTypeStruct();
            valueTypeStructInstance.Method();
        }
  • _referenceTypeField这个对象的变量在栈上(保存地址),值在堆上
  • referenceTypeLocalVariable这个对象的变量在栈上(保存地址),值在堆上

综上所述:

  • 方法的局部变量:根据变量自身决定,跟所在的环境没关系
  • 对象是引用类型,其属性/字段,都是在堆里面
  • 对象是值类型,其属性/字段,值类型就在栈里 引用类型就在堆里
  • 引用类型任何时候都在堆里;值类型都在栈里, 除非值类型所在对象是在堆里(ReferencePoint这个例子就是)

装箱和拆箱(C# 编程指南)

            {
                int i = 0;
                object oValue = i;
                i = (int)oValue;
            }
  • 装箱拆箱(仅仅是说内存的拷贝动作):内存copy 也会浪费性能 通常都是因为object
  • 装箱拆箱只能发生在父子类里面, 否则无法转换

string字符串内存分配

                string student = "菜鸟海澜";//开辟一块儿内存  放入“菜鸟海澜“  返还一个引用(student变量)
                string student2 = student;//把student的引用copy一份儿给student2

                Console.WriteLine(student);//打印结果 菜鸟海澜
                Console.WriteLine(student2);//打印结果 菜鸟海澜

                student2 = "菜鸟";
                Console.WriteLine(student);//打印结果 :菜鸟海澜
                Console.WriteLine(student2);//打印结果:菜鸟
  • 改了student2的值 但是不是修改内存;因为string字符串的内存是不可变的
  • 赋值其实是new string(APP),重新开辟内存,返回引用
  • 不可变是因为享元,可能有多个变量指向同一个字符串,字符串变化了,多个变量都会受到影响。(例如多个类中的不同字符串变量都声明 "菜鸟海澜",本质上都是指向一个地址)
  • 还因为堆里面的内存是连续分配的,如果变长度,会导致大量数据的移动
                string student = "菜鸟海澜";
                string student2 = "菜鸟";//共享
                student2 = "菜鸟海澜";
                Console.WriteLine(object.ReferenceEquals(student, student2));//打印结果为 True
  • 就是同一个 享元模式 CLR内存分配字符串的时候,会查找相同值,有就重用了
    使用享元的主要原因:
  • 因为在堆中每个对象的内存都是紧密连接的,使用享元且不可改变,这样可以提高内存的使用率。
  • 避免导致大量数据的移动,降低内存的重新分配、摆放(有不同的线程栈,但共用一个堆)。

垃圾回收

参考自 垃圾回收清理非托管资源

网上一位开发者的文章:https://kb.cnblogs.com/page/106720/

首先简述一下线程栈和托管堆的概念

  • 值类型出现在线程栈:每次调用都有线程栈,,用完自己就结束,变量-值类型 都会释放的(不用我们维护)
  • 引用类型出现在堆里:全局就一个堆,空间有限,所以才需要垃圾回收
  • 操作系统里面,内存是链式分配的,可能有碎片的
  • CLR的堆:连续分配(数组),空间有限,节约空间
  • 大对象策略:如果该对象占用内存大于85000字节,属于大对象,单独管理,用的是链表(碎片),避免频繁的内存移动造成性能消耗

下面要说的垃圾回收主要是以堆中的操作为主要内容

GC(Garbage Collector 的缩写)

1问:什么是垃圾?

  • 垃圾是完全访问不到的东西了。例如临时变量,或者已经赋值为null的引用类型的变量

2问:什么时候会发生GC?

  • gc发生在new的时候 new一个对象时,会开辟内存,看看空间够不够,不够的话就要GC了
  • gc程序退出的时候也会gc
  • 手动GC。例如定时程序,很久执行一次,而且使用的时长很短,这时候就可以手动GC了

3问:怎么回收?

  • new的时候发现内存不够,然后就去遍历所有堆的对象,标记有引用的对象,然后启动一个线程来清理内存
  • 清除没有标记的对象,挪动其他剩余对象,然后整齐摆放,所以这个时候全部线程停止(开多线程时这个时候是停止的),不允许操作内存
  • 内存不够的是指一级对象的内存,有个临界值,也不是全部的堆的大小
  • 但是类中含有 析构函数【~类名称()】 ,内存的释放就需要单独的处理,把这些对象放入一个队列单独处理,具体哪一时刻调用析构函数不确定

    注意:静态的对象是不会被回收的,且持有的引用也是不会被回收的

关于垃圾回收第几代的问题官方文档是这么说明的

在下面的例子中,声明一个静态变量staticStudent ,调用Test方法后主动调用GC,最终 变量【student】【@class】会被回收,但他们对应在堆中的内容不会被回收,因为有staticStudent 持有,变量 【i】会在弹栈之后直接被回收,变量【gCTest】以及它对应在堆中的内容都会被回收

        private static Student staticStudent = new Student()//静态的不可能被回收   静态持有的引用也不会被回收
        {
            Id = 123,
            Name = "菜鸟海澜"
        };
        public void Test()
        {
            Student student = staticStudent;
            Class @class = new Class()
            {
                classId = 1,
                classdata = "数据"
            };
            student.tempdata = @class;
            int i = 0;//都会被GC
            GCTest gCTest = new GCTest();//都会被GC
        }

在下面的示例中,很多开发者会把一个非静态变量设置成null,其实编译器会无视这句话,不是改成null这个对象没有了,其实内存还占用着,把对象赋值成null 意义不大,垃圾回收主要的原因是因为访问不到。但是静态可以把变量设置成null,促进垃圾回收,这样可以让变量不再被引用

                Student student = new Student()
                {
                    Id = 1,
                    Name = "su9257",
                    tempdata = new Class()
                    {
                        classId = 1,
                        classdata = "数据1"
                    }
                };
                student = null;
                GC.Collect();

非托管资源的释放

关于释放非托管资源必须要谈到的两个东西:【析构函数】和【Disposable】

析构函数
  • 析构函数 主要是用来释放非托管资源(函数中调用具体释放资源的API或方法),等着GC的时候去把非托管资源释放掉 系统自动执行
  • GC回收的时候,CLR一定调用的,但是可能有延迟,具体是哪个时刻不确定
Dispose
  • Dispose() 也是释放非托管资源的,主动释放(或手动调用),方法本身是没有意义的,我们需要在方法里面实现对资源的释放
  • GC不会调用,而是用对象时,使用者主动调用这个方法,去释放非托管资源

不过Dispose有一个自动调用的方法,就是使用【using】关键字,在using语句块运行完时自动调用Dispose方法(前提有的情况下)。且在Dispose方法中调用GC.SuppressFinalize(this);就是告诉CLR这个类我要释放的东西已经释放完了,你就不用调用析构函数了

                using (Student student = new Student())
                {
                    Console.WriteLine("菜鸟海澜");
                }

    public class People : IDisposable
    {
        public string Remark { get; set; }
        public virtual void Dispose()
        {
            Console.WriteLine($"执行{this.GetType().Name}Dispose");
        }
    }

    public class Student : People, IDisposable
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public Class tempdata { get; set; }

        public override void Dispose()//提供主动释放方式
        {
            base.Dispose();//把我引用的其他东西给清理掉
            if (this.tempdata != null)
            {
                this.tempdata.Dispose();
            }
            //通知垃圾回收机制不再调用终结器(析构器)
            GC.SuppressFinalize(this);
        }

本质上是调用try finally

                try
                { }
                finally
                {
                    //调用的dispose()
                }

发表评论