C#如何安全、高效地玩轉任何種類的內存之Span的本質

一、what - 痛點是什么？

回答這個問題前，先總結一下如何用C#操作任何類型的內存：

1、托管內存（managed memory ）

var mangedMemory = new Student();

很熟悉吧，只需使用new操作符就分配了一塊托管堆內存，而且還不用手工釋放它，因為它是由垃圾收集器（GC）管理的，GC會智能地決定何時釋放它，這就是所謂的托管內存。默認情況下，GC通過復制內存的方式分代管理小對象（size < 85000 bytes），而專門為大對象（size >= 85000 bytes）開辟大對象堆（LOH），管理大對象時，并不會復制它，而是將其放入一個列表，提供較慢的分配和釋放，而且很容易產生內存碎片。

2、棧內存（stack memory ）

unsafe{
    var stackMemory = stackalloc byte[100];
}

很簡單，使用stackalloc關鍵字非常快速地就分配好了一塊棧內存，也不用手工釋放，它會隨著當前作用域而釋放，比如方法執(zhí)行結束時，就自動釋放了。棧內存的容量非常小（ ARM、x86 和 x64 計算機，默認堆棧大小為 1 MB），當你使用棧內存的容量大于1M時，就會報StackOverflowException 異常 ，這通常是致命的，不能被處理，而且會立即干掉整個應用程序，所以棧內存一般用于需要小內存，但是又不得不快速執(zhí)行的大量短操作，比如微軟使用棧內存來快速地記錄ETW事件日志。

3、本機內存（native memory ）

IntPtr nativeMemory0 = default(IntPtr), nativeMemory1 = default(IntPtr);
try
{
    unsafe
    {
        nativeMemory0 = Marshal.AllocHGlobal(256);
        nativeMemory1 = Marshal.AllocCoTaskMem(256);
    }
}
finally
{
    Marshal.FreeHGlobal(nativeMemory0);
    Marshal.FreeCoTaskMem(nativeMemory1);
}

通過調用方法Marshal.AllocHGlobal 或Marshal.AllocCoTaskMem 來分配非托管堆內存，非托管就是垃圾回收器（GC）不可見的意思，并且還需要手工調用方法Marshal.FreeHGlobal or Marshal.FreeCoTaskMem 釋放它，千萬不能忘記，不然就內存泄漏了。

二、拋磚引玉 - 痛點

首先我們設計一個解析完整或部分字符串為整數(shù)的API，如下：

public interface IntParser
{
    // allows us to parse the whole string.
    int Parse(string managedMemory);

    // allows us to parse part of the string.
    int Parse(string managedMemory, int startIndex, int length);

    // allows us to parse characters stored on the unmanaged heap / stack.
    unsafe int Parse(char* pointerToUnmanagedMemory, int length);

    // allows us to parse part of the characters stored on the unmanaged heap / stack.
    unsafe int Parse(char* pointerToUnmanagedMemory, int startIndex, int length); 
}

從上面可以看到，為了支持解析來自任何內存區(qū)域的字符串，一共寫了4個重載方法。

接下來在來設計一個支持復制任何內存塊的API，如下：

public interface MemoryblockCopier
{
    void Copy<T>(T[] source, T[] destination);
    void Copy<T>(T[] source, int sourceStartIndex, T[] destination, int destinationStartIndex, int elementsCount);
    unsafe void Copy<T>(void* source, void* destination, int elementsCount);
    unsafe void Copy<T>(void* source, int sourceStartIndex, void* destination, int destinationStartIndex, int elementsCount);
    unsafe void Copy<T>(void* source, int sourceLength, T[] destination);
    unsafe void Copy<T>(void* source, int sourceStartIndex, T[] destination, int destinationStartIndex, int elementsCount);
}

腦袋蒙圈沒，以前C#操縱各種內存就是這么復雜、麻煩。通過上面的總結如何用C#操作任何類型的內存，相信大多數(shù)同學都能夠很好地理解這兩個類的設計，但我心里是沒底的，因為使用了不安全代碼和指針，這些操作是危險的、不可控的，根本無法獲得.net至關重要的安全保障，并且可能還會有難以預估的問題，比如堆棧溢出、內存碎片、棧撕裂等等，微軟的工程師們早就意識到了這個痛點，所以span誕生了，它就是這個痛點的解決方案。

三、how - span如何解決這個痛點？

先來看看，如何使用span操作各種類型的內存（偽代碼）：

1、托管內存（managed memory ）

var managedMemory = new byte[100];
Span<byte> span = managedMemory;

2、棧內存（stack memory ）

var stackedMemory = stackalloc byte[100];
var span = new Span<byte>(stackedMemory, 100);

3、本機內存（native memory ）

var nativeMemory = Marshal.AllocHGlobal(100);
var nativeSpan = new Span<byte>(nativeMemory.ToPointer(), 100);

span就像黑洞一樣，能夠吸收來自于內存任意區(qū)域的數(shù)據(jù)，實際上，現(xiàn)在，在.Net的世界里，Span就是所有類型內存的抽象化身，表示一段連續(xù)的內存，它的API設計和性能就像數(shù)組一樣，所以我們完全可以像使用數(shù)組一樣地操作各種內存，真的是太方便了。

現(xiàn)在重構上面的兩個設計，如下：

public interface IntParser
{
    int Parse(Span<char> managedMemory);
    int Parse(Span<char>, int startIndex, int length);
}
public interface MemoryblockCopier
{
    void Copy<T>(Span<T> source, Span<T> destination); 
    void Copy<T>(Span<T> source, int sourceStartIndex, Span<T> destination, int destinationStartIndex, int elementsCount);
}

上面的方法根本不關心它操作的是哪種類型的內存，我們可以自由地從托管內存切換到本機代碼，再切換到堆棧上，真正的享受玩轉內存的樂趣。

四、why - 為什么span能解決這個痛點？

1、淺析span的工作機制

先來窺視一下源碼：

我已經圈出的三個字段：偏移量、索引、長度（使用過ArraySegment<byte> 的同學可能已經大致理解到設計的精髓了），這就是它的主要設計，當我們訪問span表示的整體或部分內存時，內部的索引器會按照下面的算法運算指針（偽代碼）：

ref T this[int index]
{
    get => ref ((ref reference + byteOffset) + index * sizeOf(T));
}

整個變化的過程，如圖所示：

上面的動畫非常清楚了吧，舊span整合它的引用和偏移成新的span的引用，整個過程并沒有復制內存，也沒有返回相對位置上存在的副本，而是直接返回實際存儲位置的引用，因此性能非常高，因為新span獲得并更新了引用，所以垃圾回收器（GC）知道如何處理新的span，從而獲得了.Net至關重要的安全保障，并且內部還會自動執(zhí)行邊界檢查確保內存安全，而這些都是span內部默默完成的，開發(fā)人員根本不用擔心，非托管世界依然美好。
正是由于span的高性能，目前很多基礎設施都開始支持span，甚至使用span進行重構，比如：System.String.Substring方法，我們都知道此方法是非常消耗性能的，首先會創(chuàng)建一個新的字符串，然后再從原始字符串中復制字符集給它，而使用span可以實現(xiàn)Non-Allocating、Zero-coping，下面是我做的一個基準測試：

使用String.SubString和Span.Slice分別截取長度為10和1000的字符串的前一半，從指標Mean可以看出方法SubString的耗時隨著字符串長度呈線性增長，而Slice幾乎保持不變；從指標Allocated Memory/Op可以看出，方法Slice并沒有被分配新的內存，實踐出真知，可以預見Span未來將會成為.Net下編寫高性能應用程序的重要積木，應用前景也會非常地廣，微服務、物聯(lián)網(wǎng)、云原生都是它發(fā)光發(fā)熱的好地方。

從技術的本質上看，Span<T>是一種ref-like type類似引用的結構體；從應用的場景上看，它是高性能的sliceable type可切片類型；綜上所訴，Span是一種類似于數(shù)組的結構體，但具有創(chuàng)建數(shù)組一部分視圖，而無需在堆上分配新對象或復制數(shù)據(jù)的超能力。

補充：

可能會有的同學誤解了span，表面上認為只是對指針的封裝，從而繞過unsafe帶來的限制，避免開發(fā)人員直接面對指針而已，其實不是，下面我們來看一個示例：

var nativeMemory = Marshal.AllocHGlobal(100);
Span<byte> nativeSpan;
unsafe {
nativeSpan = new Span<byte>(nativeMemory.ToPointer(), 100);
}
SafeSum(nativeSpan);
Marshal.FreeHGlobal(nativeMemory);

// 這里不關心操作的內存類型，即不用為一種類型寫一個重載方法，就好比上面的設計一樣。
static ulong SafeSum(Span<byte> bytes) {
ulong sum = 0;
for(int i=0; i < bytes.Length; i++) {
sum += bytes[i];
}
return sum;
}

并沒有繞過unsafe，以前該如何用，現(xiàn)在還是一樣的，span解決的是下面幾點：

1. 高性能，避免不必要的內存分配和復制。
2. 高效率，它可以為任何具有無復制語義的連續(xù)內存塊提供安全和可編輯的視圖，極大地簡化了內存操作，即不用為每一種內存類型操作寫一個重載方法。
3. 內存安全，span內部會自動執(zhí)行邊界檢查來確保安全地讀寫內存，但它并不管理如何釋放內存，而且也管理不了，因為所有權不屬于它，希望大家要明白這一點。

以上就是C#如何安全、高效地玩轉任何種類的內存之Span的本質的詳細內容，更多關于C#語言的資料請關注腳本之家其它相關文章！,希望大家以后多多支持腳本之家！

最新評論