起因

在日常项目中,很多时候都是在处理字符串,由于字符串的不可变性,会生成很多新的字符串,产生新的字符串意味着需要内存分配和进行垃圾回收(GC),频繁产生新的字符串,也会让GC频繁地回收,即使GC机制一直在改进,即使GC并行回收,也会短暂得阻塞当前程序所有线程进行垃圾回收.

在.Net Core引入Span,Span和数组不同,可以高效的与托管内存和非托管内存,甚至是栈上的交互.最主要的是类型安全和操作内存也是安全的.使用Span可以减少内存的分配,是可以提高性能的.

以往我们用用句柄处理非托管内存,要手动申请和手动释放,使用Span不用手动释放,由GC进行回收.

Span使用和分析

static void Span1()
{
    var arr = new byte[10];
    Span<byte> bytes = arr;                     //bytes指向arr的引用

    for (int i = 0; i < arr.Length; i++)
    {
        bytes[i] = (byte)(i + 1);                   //修改bytes数组的值
    }

    Span<byte> slicedBytes = bytes.Slice(5, 2);  //bytes.Slice(5, 2)返回bytes下标为为5,长度为2的内容
}

根据上面的代码,进行分析

1. 分析bytes和arr是不是指向同一块内存空间.
2. 分析bytes.Slice是否进行了内存分配

(1)先看一下arr在堆中的内存分配,先将代码执行到

(2)打开即时窗口,输入 &(arr[0]) ,得到arr[0]在内存的地址.

(3)打开内存窗口,根据在即时窗口拿到的地址,查看在内存中的分配

看到arr的起止地址为0x0000019983091150,结束位置0x0000019983091159,arr在一段连续内存空间内.

到这里,我们学会了如何获取在内存中的地址和查看内存分配

回到我们上面2个问题.

问题1,我们只要查看bytes[0]和arr[0]是否为同一个内存地址.

问题2,我们查看slicedBytes[0]和bytes[5]是否为同一个内存地址.得出的结论:通过内存地址比较.没有进行新的内存分配

Span在栈空间使用

/// <summary>
/// 在栈上分配空间,在栈上分配的内存在离开其所在的作用域自动释放
/// </summary>
static void Span2()
{
    int i = 42;
    Span<byte> stackBytes = stackalloc byte[2];     //c#语言版本 7.0以上支持
    stackBytes[0] = 42;
    stackBytes[1] = 43;
}

我们知道在c#中,基本类型是分配在栈上的.通过stackalloc关键字也可以将数组类型分配在栈上.使用栈可以提高程序的性能.只是栈的空间有限.需要合理使用.

Span与句柄交互

/// <summary>
/// Span与句柄交互
/// 使用AllocHGlobal(非托管内存分配),要与FreeHGlobal(释放内存)结对
/// </summary>
static void Span3()
{
    IntPtr ptr = Marshal.AllocHGlobal(1);
    try
    {
        Span<byte> b;
        unsafe                              //使用指针,要加unsafe关键字
        {
            b = new Span<byte>((byte*)ptr, 1);
        }
        b[0] = 42;

        byte val1 = Marshal.ReadByte(ptr);
        Console.WriteLine(val1 == b[0]);
    }
    finally
    {
        Marshal.FreeHGlobal(ptr);
    }
}

ReadOnlySpan在String中使用

/// <summary>
/// ReadOnlySpan在String使用
/// Substring和Slice对比
/// </summary>
static void ReadOnlySpan1()
{
    string str = "hello word,hello csharp!";
           
    string newStr = str.Substring(2, 5);                        //返回新的字符串,要重新分配内存

    ReadOnlySpan<char> readOnlySpan = str.AsSpan().Slice(2, 5); //返回的不是新产生的字符串,这里没有内存分配,内部用指针移到str的地址上    

    //由于无法直接使用&(str[0])和&(readOnlySpan[0])获取内存的地址
    //这里使用魔法黑科技-指针
    unsafe
    {
        fixed (char* p1 = str)
        {
            fixed (char* p2 = readOnlySpan)
            {

            }
        }
    }
}

通过p1和p2的地址,查看在内存中的分配.

我们一起阅读Span源码

得助于.Net Core代码开源,我们可以很方便的查看源码,将Span的代码进行裁剪.只分析几个重要的函数如构造函数等.再把函数内断言和参数校验的进行删除.

/// <summary>
/// Span represents a contiguous region of arbitrary memory. Unlike arrays, it can point to either managed
/// or native memory, or to memory allocated on the stack. It is type- and memory-safe.
/// Span和数组不同,可以高效的与托管内存和非托管内存,甚至是栈上的交互.最主要的是类型安全和操作内存也是安全的.
/// 以往我们用用句柄处理非托管内存,要手动申请和手动释放,使用Span不用手动释放
/// </summary>
public readonly ref partial struct Span<T>
{
    /// <summary>
    /// 指针
    /// </summary>
    internal readonly ByReference<T> _pointer;

    /// <summary>
    /// 记录长度
    /// </summary>
    private readonly int _length;
        
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Span(T[] array)
    {
        _pointer = new ByReference<T>(ref Unsafe.As<byte, T>(ref array.GetRawSzArrayData()));
        _length = array.Length;
    }


    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Span(T[] array, int start, int length)
    {
        _pointer = new ByReference<T>(ref Unsafe.Add(ref Unsafe.As<byte, T>(ref array.GetRawSzArrayData()), start));
        _length = length;
    }

    [CLSCompliant(false)]
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public unsafe Span(void* pointer, int length)
    {
        _pointer = new ByReference<T>(ref Unsafe.As<byte, T>(ref *(byte*)pointer));
        _length = length;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    internal Span(ref T ptr, int length)
    {
        _pointer = new ByReference<T>(ref ptr);
        _length = length;
    }

    public ref T this[int index]
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get
        {
            return ref Unsafe.Add(ref _pointer.Value, index);
        }
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Span<T> Slice(int start)
    {
        return new Span<T>(ref Unsafe.Add(ref _pointer.Value, start), _length - start);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Span<T> Slice(int start, int length)
    {
        return new Span<T>(ref Unsafe.Add(ref _pointer.Value, start), length);
    }
}

上面Span代码,可以看到Span是泛型的.内部有一个ByReference类型的指针,在ByReference内部有一个私有的IntPtr类型_value记录开始的地址,由_length记录内容长度,可以确定返回内容的结束地址.ByReference本身很简单,只是_value是在JIT(即时编译)确定的.

在Span内部可以看到满满的黑科技,如:

1.在很多函数上面都有一个特性标签 [MethodImpl(
MethodImplOptions.AggressiveInlining)],在JIT时,会确定函数是否进行内联.我们都知道函数内联是可以提高性能的,可以省掉调用函数的开销.

2.使用Unsafe指针交互.不知道是不是.Net Core版本低的缘故,无法直接使用Unsafe类.

以上内容是2018年11月日所写,在后面的.Net Core版本源码中,使用Span的地方越来越多,如Span的Fill方法源码使用Unsafe.在迁移后面的文章会有专门的介绍.