在学习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官方文档
-
.NET 中的内存管理和垃圾回收
-
什么是“托管代码”?
-
自动内存管理
-
线程栈:栈-stack 先进后出的数据结构 随着线程而分配的 默认执行方法分配1MB内存
-
对象堆:内存,进程中独立画出来的一块儿内存,有一些对象长期使用不释放的,例如static,方便对象重用(多个对象指向一个内存地址)
我们结合代码来说一下堆栈的分配
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()
}