C#高性能低GC 非托管动态扩容数组

最新推荐文章于 2023-08-06 15:55:41 发布
最新推荐文章于 2023-08-06 15:55:41 发布
阅读量740 收藏
点赞数
分类专栏： C# 文章标签： c# 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/biyusr/article/details/126785970
版权

开始之前

相比固定长度的Array，大家可能在编程的时候经常会使用List<T>，同时可能会经常往里面Add东西，因为List具有可扩容性，但是注重GC的朋友会发现（比如Unity开发者），List.Resize会造成扩容前数组长度*泛型类型所占字节长度的GC，同时会造成耗时，以及额外的内存占用（比如List有100个元素的时候触发了扩容，新容量为200，但是总共一共插入了150个元素，导致有50个分配的内存没被利用）

Stream（例如MemoryStream）与List一样，在Resize里会分配当前容量两倍的新byte托管数组，也会造成和上面提到的一样的情况，导致GC和可能存在的额外内存占用，以及拷贝托管数组的耗时。

那么有没有什么办法能实现一个：

  1. 能插入元素

  2. 能动态扩容

  3. 扩容不造成GC

  4. 能指定扩容长度

包含上述内容的动态扩容数组呢？

让我们先看看List和Stream的原理

List<T>和Stream

List<T>和Stream一样，基本是内部有一个托管数组T[]或byte[]，

内部会记录当前总容量，以及元素总数，Stream还会额外记录当前的位置

且内部实现了Resize方法，会new一个新的托管数组，长度为当前总容量的两倍

紧接着会把老数组的元素复制到新数组上，老数组不会再被引用且造成GC

Span和Memory

最近C#提供了Span和Memory类型，提供了安全操作连续内存的方法

他们的内部实现是这样的：

  1. 记录对应泛型类型的指针

  2. 记录该指针的长度（多少个元素）

Span和Memory有一点微小的区别，比如在栈上和托管堆上（Span是ref struct，Memory则是readonly struct的缘故），导致他们的用法不太一样，不过本文只需要关心他们的实现原理。

是不是发现和List<T>以及Stream很像？只是托管数组变成指针了，然后少了一些成员？

指针

指针是什么？指针就是一个变量在内存里的地址，所以叫做指针（Pointer），因为指针指向了内存内的一个变量

在内存中的变量有两种情况，一种是被GC托管的变量，一种是不被GC托管的变量，而我们的List和Stream内部的数组，就是托管数组，由GC托管。

如果对Span和Memory熟悉的，应该知道List可以直接转Span，怎么做到的呢？只需要把List内部托管的数组的指针传给Span的构造参数就行（List转Memory也可以就是需要自己实现，有点复杂）

那么延伸的想法就来了，如果我们用非托管指针代替分配的托管数组来存我们的元素，是不是就可以不被GC托管而不被产生GC了？答案是，没错。

自行分配非托管内存

如果我们需要申请非托管内存，我们需要实现以下一条很重要原则：

  • 手动申请的非托管内存必须用好后手动释放（不然就会造成野指针）

C#有两种方法申请非托管内存，并且任何能运行C#的平台都支持（Unity也是支持的，哪怕是IL2CPP）

  1. Marshal.AllocHGlobal，该方法会返回指定长度的非托管内存，并且返回的内存有可能会有值

  2. Marshal.AllocCoTaskMem，该方法会返回至少指定长度的非托管内存，但是也有可能会返回超过改长度的内存，且返回的内存不会有值（全是0）

这里很明显，第一个提到的方法适合我们的使用场景

托管的动态扩容数组类型

既然用Sturct可以避免创建时造成的GC（如Span, Memory都是struct），为什么我们要用托管类型（Class）去定义我们的动态扩容数组呢？

请看一下上面提到的原则，手动申请的非托管内存必须用好后手动释放（不然就会造成野指针）

只有通过托管类型，我们才能做到这一点：

  • 在构造函数（Constructor内申请非托管内存）

  • 在折构函数（Finalizer内释放申请的内存）

折构函数就是一个对象被GC回收前调用的函数）

实现一个非托管类型的动态扩容数组

因为非托管类型转指针比较方便，所以本文我们先实现一个非托管类型的动态扩容数组

根据我们上面提到的思路，可以得出以下代码（注，此代码不是完整体）：

/// <summary>
/// A buffer that can dynamically extend
/// </summary>
/// <typeparam name="T"></typeparam>
public sealed unsafe class ExtensibleBuffer<T> where T : unmanaged
{
 /// <summary>
 /// Init extensible buffer with a capacity
 /// </summary>
 /// <param name="size"></param>
 /// <param name="initialData"></param>
 private ExtensibleBuffer(int size, T[] initialData)
{
   sizeOfT = (byte)sizeof(T);
   ExpandSize = size;
   Data = (T*)Marshal.AllocHGlobal(sizeOfT * ExpandSize);
   if (initialData != null)
  {
     fixed(T* ptr = initialData)
    {
       CopyFrom(ptr, 0, 0, initialData.Length);
    }
  }

   TotalLength = ExpandSize;
   GC.AddMemoryPressure(sizeOfT * ExpandSize);
}
 
 /// <summary>
 /// Free allocated memories
 /// </summary>
 ~ExtensibleBuffer()
{
   Marshal.FreeHGlobal((IntPtr)Data);
   GC.RemoveMemoryPressure(sizeOfT * TotalLength);
}
}

上面的代码实现了构造函数和折构函数，其中构造函数的参数指定了扩容大小，方法内部获取了泛型T的内存大小，并且申请了类型大小*扩容数量个字节的内存，并且如果有初始化数据，就把初始化托管数据复制到非托管内存上

同时，会标记目前的总长度，以及通知GC我们有申请的内存大小的内存压力（促进GC多去回收）

折构函数内，我们释放了申请的内存，同时通知GC我们之前申请的内存大小的内存压力没了，被我们释放了（让GC不要再关系我们这个动态扩容数组了）

索引器

索引器就是数组/List返回指定位置元素的方法：

/// <summary>
/// Get element at index
/// </summary>
/// <param name="index"></param>
public T this[int index]
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
 get => Data[index];
[MethodImpl(MethodImplOptions.AggressiveInlining)]
 set
{
   EnsureCapacity(ref index);
   Data[index] = value;
}
}

我们在插入的时候检查下申请的内存就好，确保插入到有效的内存里。

实现扩容

既然要避免每次扩容都双倍现在的长度从而造成内存浪费，我们需要在构造函数里标记扩容大小，然后每次扩容的时候当前总长度+=扩容大小就好

幸运的是C#提供了一个重新分配通过Marshal.AllocHGlobal申请的内存的方法：

Marshal.ReAllocHGlobal

这个方法需要传两个参数，第一个参数是原申请的指针，第二个参数是新长度（转指针）

通过简单的封装，我们得到了：

/// <summary>
/// Ensure index exists
/// </summary>
/// <param name="index"></param>
private void EnsureCapacity(ref int index)
{
 if (index < TotalLength) return;
 while (index >= TotalLength)
{
   TotalLength += ExpandSize;
   GC.AddMemoryPressure(sizeOfT * ExpandSize);
}
 Extend();
}

/// <summary>
/// Extend buffer
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void Extend()
{
 Data = (T*)Marshal.ReAllocHGlobal((IntPtr)Data, new IntPtr(TotalLength * sizeOfT));
}

我们只需要定期触发（比如每次插入的时候，访问的话为了性能我们就不检查了，因为是指针，也不会导致数组越界，只是会返回我们想不到的结果）EnsureCapacity，来检查指定的索引是否被我们申请过，如果没的话，就动态扩容以及通知GC即可

从外部的数组/指针里复制元素

我们只需要取别的数组/指针，然后从指定偏移开始，复制指定长度到我们申请的指针的指定位置即可：

/// <summary>
/// Copy data to extensible buffer
/// </summary>
/// <param name="src"></param>
/// <param name="srcIndex"></param>
/// <param name="dstIndex"></param>
/// <param name="length"></param>
/// <exception cref="InvalidOperationException"></exception>
public void CopyFrom(T[] src, int srcIndex, int dstIndex, int length)
{
 fixed (T* ptr = src)
{
   CopyFrom(ptr, srcIndex, dstIndex, length);
}
}

/// <summary>
/// Copy data to extensible buffer
/// why unaligned? https://stackoverflow.com/a/72418388
/// </summary>
/// <param name="src"></param>
/// <param name="srcIndex"></param>
/// <param name="dstIndex"></param>
/// <param name="length"></param>
/// <exception cref="InvalidOperationException"></exception>
public void CopyFrom(T* src, int srcIndex, int dstIndex, int length)
{
 var l = dstIndex + length;
 //size check
 EnsureCapacity(ref l);
 //copy
 Unsafe.CopyBlockUnaligned(Data + dstIndex, src + srcIndex, (uint)length);
}

StackOverFlow的这篇文章：stackoverflow.com/a/724证明了不对齐的拷贝内存更快，不过这里我们是非托管类型的非托管内存，所以这样玩不会出问题

复制数据到外部的数组/指针

与上面的实现类似，我们只需要获取需要复制到的数组/指针，从我们动态扩容数组的第几个元素开始复制，复制多少个即可

注，这里如果需要复制到指定的数组位置，可以把数组转指针后+偏移，然后调用传指针的方法去复制 
/// <summary>
/// Copy data from buffer to dst from dst[0]
/// </summary>
/// <param name="dst"></param>
/// <param name="srcIndex"></param>
/// <param name="length"></param>
/// <exception cref="OverflowException"></exception>
public void CopyTo(ref T[] dst, int srcIndex, int length)
{
 fixed (T* ptr = dst)
{
   CopyTo(ptr, srcIndex, length);
}
}

/// <summary>
/// Copy data from buffer to dst from dst[0]
/// </summary>
/// <param name="dst"></param>
/// <param name="srcIndex"></param>
/// <param name="length"></param>
/// <exception cref="OverflowException"></exception>
public void CopyTo(T* dst, int srcIndex, int length)
{
 var l = srcIndex + length;
 //size check
 EnsureCapacity(ref l);
 //copy
 Unsafe.CopyBlockUnaligned(dst, Data + srcIndex, (uint)length);
}

转Span

Span特别有用，在切割内存之类的地方没有什么比Span更适合的了，所以我们顺便把转Span也支持吧

显示转换

/// <summary>
/// convert an extensible to buffer from start index with provided length
/// </summary>
/// <param name="startIndex"></param>
/// <param name="length"></param>
/// <returns></returns>
public Span<T> AsSpan(int startIndex, int length)
{
 var l = startIndex + length;
 //size check
 EnsureCapacity(ref l);
 return new Span<T>(Data + startIndex, length);
}

这样我们可以从指定位置开始讲指定长度个元素转为Span，同时操作返回的Span可以直接操作到我们这个动态扩容数组内的元素上（因为操作Span的元素相当于直接操作内存）

隐式转换

/// <summary>
/// Convert to span
/// </summary>
/// <param name="buffer"></param>
/// <returns></returns>
public static implicit operator Span<T>(ExtensibleBuffer<T> buffer) => buffer.AsSpan(0, buffer.TotalLength);

这里我们从第0个元素开始把当前总长度个元素转Span

转托管数组

因为有可能需要给其他接口使用，所以我们需要能把非托管数组的数据复制到托管数组，只需要new个托管数组然后调用复制的接口即可

/// <summary>
/// Convert buffer data to an Array (will create a new array and copy values)
/// </summary>
/// <param name="startIndex"></param>
/// <param name="length"></param>
/// <returns></returns>
public T[] ToArray(int startIndex, int length)
{
 T[] ret = new T[length];
 CopyTo(ref ret, startIndex, length);
 return ret;
}

完整代码

可以在GitHub上看：Nino，当然我本人更希望大家来点star，也可以看下面贴出的代码：

using System;
using System.Runtime.InteropServices;
using System.Runtime.CompilerServices;

namespace Nino.Shared.IO
{
 /// <summary>
 /// A buffer that can dynamically extend
 /// </summary>
 /// <typeparam name="T"></typeparam>
 public sealed unsafe class ExtensibleBuffer<T> where T : unmanaged
{
   /// <summary>
   /// Default size of the buffer
   /// </summary>
   private const int DefaultBufferSize = 128;

   /// <summary>
   /// Data that stores everything
   /// </summary>
   public T* Data { get; private set; }

   /// <summary>
   /// Size of T
   /// </summary>
   private readonly byte sizeOfT;

   /// <summary>
   /// expand size for each block
   /// </summary>
   public readonly int ExpandSize;

   /// <summary>
   /// Total length of the buffer
   /// </summary>
   public int TotalLength { get; private set; }

   /// <summary>
   /// Init buffer
   /// </summary>
   public ExtensibleBuffer() : this(DefaultBufferSize)
  {

  }

   /// <summary>
   /// Init buffer
   /// </summary>
   public ExtensibleBuffer(int expandSize) : this(expandSize, null)
  {

  }

   /// <summary>
   /// Init extensible buffer with a capacity
   /// </summary>
   /// <param name="size"></param>
   /// <param name="initialData"></param>
   private ExtensibleBuffer(int size, T[] initialData)
  {
     sizeOfT = (byte)sizeof(T);
     ExpandSize = size;
     Data = (T*)Marshal.AllocHGlobal(sizeOfT * ExpandSize);
     if (initialData != null)
    {
       fixed(T* ptr = initialData)
      {
         CopyFrom(ptr, 0, 0, initialData.Length);
      }
    }

     TotalLength = ExpandSize;
     GC.AddMemoryPressure(sizeOfT * ExpandSize);
  }

   /// <summary>
   /// Get element at index
   /// </summary>
   /// <param name="index"></param>
   public T this[int index]
  {
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     get => Data[index];
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     set
    {
       EnsureCapacity(ref index);
       Data[index] = value;
    }
  }

   /// <summary>
   /// Ensure index exists
   /// </summary>
   /// <param name="index"></param>
   private void EnsureCapacity(ref int index)
  {
     if (index < TotalLength) return;
     while (index >= TotalLength)
    {
       TotalLength += ExpandSize;
       GC.AddMemoryPressure(sizeOfT * ExpandSize);
    }
     Extend();
  }

   /// <summary>
   /// Extend buffer
   /// </summary>
  [MethodImpl(MethodImplOptions.AggressiveInlining)]
   private void Extend()
  {
     Data = (T*)Marshal.ReAllocHGlobal((IntPtr)Data, new IntPtr(TotalLength * sizeOfT));
  }

   /// <summary>
   /// Convert buffer data to an Array (will create a new array and copy values)
   /// </summary>
   /// <param name="startIndex"></param>
   /// <param name="length"></param>
   /// <returns></returns>
   public T[] ToArray(int startIndex, int length)
  {
     T[] ret = new T[length];
     CopyTo(ref ret, startIndex, length);
     return ret;
  }

   /// <summary>
   /// convert an extensible to buffer from start index with provided length
   /// </summary>
   /// <param name="startIndex"></param>
   /// <param name="length"></param>
   /// <returns></returns>
   public Span<T> AsSpan(int startIndex, int length)
  {
     var l = startIndex + length;
     //size check
     EnsureCapacity(ref l);
     return new Span<T>(Data + startIndex, length);
  }

   /// <summary>
   /// Convert to span
   /// </summary>
   /// <param name="buffer"></param>
   /// <returns></returns>
   public static implicit operator Span<T>(ExtensibleBuffer<T> buffer) => buffer.AsSpan(0, buffer.TotalLength);

   /// <summary>
   /// Copy data to extensible buffer
   /// </summary>
   /// <param name="src"></param>
   /// <param name="srcIndex"></param>
   /// <param name="dstIndex"></param>
   /// <param name="length"></param>
   /// <exception cref="InvalidOperationException"></exception>
   public void CopyFrom(T[] src, int srcIndex, int dstIndex, int length)
  {
     fixed (T* ptr = src)
    {
       CopyFrom(ptr, srcIndex, dstIndex, length);
    }
  }

   /// <summary>
   /// Copy data to extensible buffer
   /// why unaligned? https://stackoverflow.com/a/72418388
   /// </summary>
   /// <param name="src"></param>
   /// <param name="srcIndex"></param>
   /// <param name="dstIndex"></param>
   /// <param name="length"></param>
   /// <exception cref="InvalidOperationException"></exception>
   public void CopyFrom(T* src, int srcIndex, int dstIndex, int length)
  {
     var l = dstIndex + length;
     //size check
     EnsureCapacity(ref l);
     //copy
     Unsafe.CopyBlockUnaligned(Data + dstIndex, src + srcIndex, (uint)length);
  }

   /// <summary>
   /// Copy data from buffer to dst from dst[0]
   /// </summary>
   /// <param name="dst"></param>
   /// <param name="srcIndex"></param>
   /// <param name="length"></param>
   /// <exception cref="OverflowException"></exception>
   public void CopyTo(ref T[] dst, int srcIndex, int length)
  {
     fixed (T* ptr = dst)
    {
       CopyTo(ptr, srcIndex, length);
    }
  }

   /// <summary>
   /// Copy data from buffer to dst from dst[0]
   /// </summary>
   /// <param name="dst"></param>
   /// <param name="srcIndex"></param>
   /// <param name="length"></param>
   /// <exception cref="OverflowException"></exception>
   public void CopyTo(T* dst, int srcIndex, int length)
  {
     var l = srcIndex + length;
     //size check
     EnsureCapacity(ref l);
     //copy
     Unsafe.CopyBlockUnaligned(dst, Data + srcIndex, (uint)length);
  }

   /// <summary>
   /// Free allocated memories
   /// </summary>
   ~ExtensibleBuffer()
  {
     Marshal.FreeHGlobal((IntPtr)Data);
     GC.RemoveMemoryPressure(sizeOfT * TotalLength);
  }
}
}

Benchmark

就这样，我们理论上低GC高性能的非托管动态扩容数组就做好了，让我们分析一下性能，测试代码：

BenchmarkDotNet=v0.13.1, OS=macOS Monterey 12.0.1 (21A559) [Darwin 21.1.0]
Intel Core i9-8950HK CPU 2.90GHz (Coffee Lake), 1 CPU, 12 logical and 6 physical cores
.NET SDK=6.0.301
[Host]   : .NET 6.0.6 (6.0.622.26707), X64 RyuJIT
ShortRun : .NET 6.0.6 (6.0.622.26707), X64 RyuJIT

Job=ShortRun Platform=AnyCpu Runtime=.NET 6.0  
IterationCount=1 LaunchCount=1 WarmupCount=1

首先我们测试了ExtensibleBuffer和List的无优化版(V1，不指定扩容/初始长度)，以及优化版（V2，指定扩容/初始长度）

同时我们测试了byte（1字节）作为泛型类型，以及int（4字节）作为泛型类型

我们先看看100个元素的插入：

MethodtestCountMeanErrorGen 0Gen 1Gen 2Allocated
ByteExtensibleBufferInsertV1100466.7 nsNA0.02770.02770.027740 B
ByteExtensibleBufferInsertV2100440.4 nsNA0.02190.02190.021940 B
ByteListInsertV1100273.6 nsNA0.0687--432 B
ByteListInsertV2100173.2 nsNA0.0253--160 B
IntExtensibleBufferInsertV1100663.2 nsNA0.11730.11730.117340 B
IntExtensibleBufferInsertV2100645.4 nsNA0.08580.08580.085840 B
IntListInsertV1100299.2 nsNA0.1884--1,184 B
IntListInsertV2100192.1 nsNA0.0725--456 B

为什么会比List略慢？因为申请内存是有耗时的，虽然基本无感知。不过GC的优化是不是挺不错的？

我们现在看看1000个元素的插入：

MethodtestCountMeanErrorGen 0Gen 1Gen 2Allocated
ByteExtensibleBufferInsertV110003,323.6 nsNA0.23270.23270.232740 B
ByteExtensibleBufferInsertV210001,560.3 nsNA0.23650.23650.236540 B
ByteListInsertV110001,917.9 nsNA0.3643--2,296 B
ByteListInsertV210001,554.6 nsNA0.1678--1,056 B
IntExtensibleBufferInsertV110003,080.0 nsNA0.96890.96890.968941 B
IntExtensibleBufferInsertV21000989.2 nsNA0.92510.92510.925141 B
IntListInsertV110002,445.4 nsNA1.3390--8,424 B
IntListInsertV210001,868.7 nsNA0.6447--4,056 B

速度是不是基本一样了？但是GC是不是少了特别特别多？

现在看看1000以上的元素的插入：

MethodtestCountMeanErrorGen 0Gen 1Gen 2Allocated
ByteExtensibleBufferInsertV11000025,683.9 nsNA2.34992.34992.349942 B
ByteExtensibleBufferInsertV21000011,535.0 nsNA2.34992.34992.349942 B
ByteListInsertV11000017,051.6 nsNA5.2490--33,112 B
ByteListInsertV21000016,544.9 nsNA1.5869--10,056 B
IntExtensibleBufferInsertV11000025,945.4 nsNA9.58259.58259.582546 B
IntExtensibleBufferInsertV2100009,269.5 nsNA8.23978.23978.239746 B
IntListInsertV11000023,988.9 nsNA20.8130--131,400 B
IntListInsertV21000016,521.5 nsNA6.3477--40,056 B
ByteExtensibleBufferInsertV1100000276,784.6 nsNA22.949222.949222.949256 B
ByteExtensibleBufferInsertV2100000121,097.0 nsNA23.559623.559623.559656 B
ByteListInsertV1100000247,649.4 nsNA205.3223205.322334.4238262,583 B
ByteListInsertV2100000213,715.3 nsNA161.1328161.132826.8555100,074 B
IntExtensibleBufferInsertV1100000244,882.5 nsNA93.750093.750093.7500109 B
IntExtensibleBufferInsertV2100000111,195.8 nsNA86.303786.303786.303782 B
IntListInsertV1100000533,471.8 nsNA619.1406619.1406233.39841,049,161 B
IntListInsertV2100000326,374.4 nsNA265.6250265.625099.6094400,123 B
ByteExtensibleBufferInsertV110000002,656,296.6 nsNA226.5625226.5625226.5625195 B
ByteExtensibleBufferInsertV210000001,214,632.2 nsNA197.2656197.2656197.2656174 B
ByteListInsertV110000002,422,943.3 nsNA1394.53131394.5313398.43752,097,906 B
ByteListInsertV210000001,636,061.4 nsNA207.0313207.0313197.26561,000,185 B
IntExtensibleBufferInsertV110000003,663,844.0 nsNA851.5625851.5625851.5625547 B
IntExtensibleBufferInsertV21000000857,195.9 nsNA498.0469498.0469498.0469377 B
IntListInsertV110000003,717,760.8 nsNA1054.68751039.06251000.00008,389,735 B
IntListInsertV210000002,265,089.4 nsNA511.7188511.7188492.18754,000,381 B
ByteExtensibleBufferInsertV11000000029,853,310.2 nsNA1656.25001656.25001656.25001,178 B
ByteExtensibleBufferInsertV21000000010,881,063.5 nsNA984.3750984.3750984.3750714 B
ByteListInsertV11000000030,683,668.0 nsNA3312.50003312.50001625.000033,556,204 B
ByteListInsertV21000000016,752,229.2 nsNA593.7500593.7500437.500010,000,366 B
IntExtensibleBufferInsertV11000000052,335,791.2 nsNA2500.00002500.00002500.00001,802 B
IntExtensibleBufferInsertV2100000008,783,753.0 nsNA984.3750984.3750984.3750714 B
IntListInsertV11000000078,802,672.6 nsNA5142.85715142.85713000.0000134,220,415 B
IntListInsertV21000000033,037,550.0 nsNA937.5000937.5000937.500040,001,345 B
ByteExtensibleBufferInsertV1100000000297,324,344.5 nsNA5000.00005000.00005000.00003,808 B
ByteExtensibleBufferInsertV2100000000113,086,965.2 nsNA800.0000800.0000800.0000741 B
ByteListInsertV1100000000303,881,242.5 nsNA5500.00005500.00003000.0000268,438,564 B
ByteListInsertV2100000000172,889,432.0 nsNA666.6667666.6667666.6667100,002,269 B
IntExtensibleBufferInsertV1100000000394,704,429.0 nsNA12000.000012000.000012000.00009,536 B
IntExtensibleBufferInsertV210000000077,565,079.3 nsNA1000.00001000.00001000.0000848 B
IntListInsertV1100000000690,861,266.0 nsNA8000.00008000.00003000.00001,073,746,576 B
IntListInsertV2100000000310,024,197.0 nsNA500.0000500.0000500.0000400,001,880 B

速度是不是快了好几倍（毕竟直接在指针上复制会快很多，也少了托管数组分配的耗时），GC是不是少了几千、几万、几十万倍？

使用场景

有人可能会问，这玩意儿有使用场景吗？

答案是有的，且很多。

  • 基本上用Stream持续写入二进制数据的使用场景都很契合这个非托管动态扩容数组（如网络IO），因为这种IO都是KB/MB/GB级别的，而在这个量级下，该动态扩容数组有着出色的性能和卓越的GC优化

  • 序列化这种需要不断写入数据的场所也很契合

  • 填充加密的使用情况也很适合（比如把二进制数据每n字节之间插入m字节的假数据，最后再转托管byte数组返回出去，可以用这个动态扩容数组在塞入假数据期间实现无GC高性能处理）

  • TCP粘包处理也很契合（类似上面提到的网络IO，但是不太一样，因为要不断地Enqueue二进制数据到扩容数组，然后如果满足包头记录的总长度了，就Dequeue出去，把后面的内容移动到最前面，以后会有这个方案的文章）

  • 还有很多很多的用途，比如通过非托管动态扩容数组写数据，然后用其非托管数据的指针，传递给C/C++等原生代码去实现无GC的高性能功能（这个以后也会有文章，关于搭配这个和Zlib native的文章）

最后

为什么不是无GC非托管动态扩容数组呢？因为我们这个数组是个对象，所以造成GC。

特别感谢阅读到最后的朋友，希望能给大家带来帮助，以后我还会写一个收集对象的内存地址，转IntPtr实现的低GC托管动态扩容数组。

biyusr
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#托管内存与非托管内存之间的转换的实例讲解
08-25
在本篇文章里小编给大家整理了关于C#托管内存与非托管内存之间的转换的实例以及相关知识点，需要的朋友们学习下。
C# byte数组常用扩展 八种情况
July.Code的网络笔记
03-25 1500
C# byte数组常用扩展是我们编程中经常会碰到的一些实用性很强的操作，那么C# byte数组常用扩展都有哪些呢？下面将列出并用实例演示常用八种情况。 C# byte数组常用扩展应用一：转换为十六进制字符串public　static　string　ToHex(this　byte　b)　　{　　return　b.ToString("X2");　　}　　　　　　public
C#数组扩容、在指定位置插入元素
qq_32109957的博客
04-25 3328
class Program { private static int[] _items = new int[5]; private static int _size = 0; public static void Add(int value) { _items[_size] = value; _size += 1; } public static void Insert(int index, int value) { .
C#--数组扩展
萍踪侠影
05-11 3088
一：数组反转 模式一： 从小到大直接反转 //从大到小排序 int[] nums = new int[] { 23, 234, 3425, 1 }; Array.Sort(nums); //排序 Array.Reverse(nums);//这个方法是反转 for (int i =...
C#Marshal.AllocHGlobal与Marshal.FreeHGlobal
wangnaisheng的专栏
02-13 1477
Marshal.AllocHGlobal与Marshal.FreeHGlobal
Marshal.AllocHGlobal()导致内存泄漏问题
snipertly的博客
06-09 6624
在将彩色Bitmap转为Halcon的HObject时，需要用指针读取图像数据，而byte*需要运行在unsafe代码块中，此时用Marshal.AllocHGlobal()分配内存后，需要手动释放，否则会造成内存泄漏，释放函数为： Marshal.FreeHGlobal() ...
C#【必备技能篇】Marshal是什么？怎么用？
星Yeah 的博客
12-09 7211
C#【必备技能篇】Marshal是什么？怎么用？
C#访问C++动态分配的数组指针(实例讲解)
08-28
下面小编就为大家分享一篇C#访问C++动态分配的数组指针(实例讲解)，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
C#中动态数组用法实例
01-01
本文实例讲述了C#中动态数组用法。分享给大家供大家参考。具体分析如下： ArrayList是一种动态数组，其容量可随着我们的需要自动进行扩充. ArrayList位于System.Collections命名空间中，所以我们在使用时，需要导入...
C#使用List类实现动态变长数组的方法
09-03
主要介绍了C#使用List类实现动态变长数组的方法,涉及C#中List类的使用技巧,具有一定参考借鉴价值,需要的朋友可以参考下
C#探索之路(4)：浅析C#中的托管、非托管堆栈与垃圾回收
qq_1628941121的博客
10-30 3362
执行回收时，垃圾回收器会在托管堆中检查应用程序不再使用的对象，然后执行必要的操作来回收其内存。但是当我回过头来了解这个垃圾回收机制的时候，我发现了一个很有意思的事情，当我去查询相关的资料的时候我发现，这其中的原理真的是一环扣一环，还环环不一样，我的内心：(TM*燃起来了！，讲述的挺好的，那我不经发出了疑问，那是不是有的Unity的C#的热更方案就有用到这个托管代码的互操作性呢？但是，请务必注意，如果采取这种方法，当代码越过运行时的边界时，实际的执行管理将再次交接到托管代码，因而需要遵守相同的限制。
C# 指针 内存控制 Marshal 内存数据存储原理
rcr676的博客
07-22 3877
了解内存的原理 # [内存] 是由 [Key] 和 [Value] 组成的： [Key] 是 [内存地址]；（在 C# 程序中用 [IntPtr] 类型表示） [Value] 是 [内存数据]；（在 C# 程序中用 [byte] 类型表示） [Key] 是一个固定32位长度的二进制数；（64位的程序则是64位长度的二进制数） [Value] 是一个固定8位长度的二进制数；（这就是计算机只能存储 0 和 1，并且最小存储单位为 byte 的原因）
C#动态分配数组大小根据实际添加的参数改变大小
Cahier
12-21 5098
现在有个需求:我有一一大串不大小固定的数据需要添加到数组中,如果给数组固定死大小的话,不太好,后来找到了方法参考这个博客 string[] roleRangeAllowUsername = new string[0]; //先定义大小为0的数组,后面经过temp.ToArray转换成数组,实现数组动态大小 string[] nullList = ...
C#与C/C++交互（1）——需要了解的基础知识
最新发布
enternalstar的博客
08-06 1503
C#中用于实现调用C/C++的方案是P/Invoke（Platform Invoke），让托管代码可以调用库中的函数。类似的功能，JAVA中叫JNI，Python中叫Ctypes。调用过程为查找dll,例子中为Test.dll'将该dll加载到内存中查找函数在内存中的地址，例子为查找Load函数，并将其参数按照函数的调用约定压栈，例子中调用约定为Cdecl将控制权转移给非托管函数。
数组的扩容的用法
Pasby的博客
03-29 468
作为一名学生，这都是我平时在学习中遇到的一些问题，不清楚不明白的地方，总结给大家的，希望能够帮助到大家 //main方法 public static void main(String[] args) { //原始数组 String names [] = new String [] {"A","B","C"}; names[0] = "A"; names[1] = "B"; names[2]...
C#笔记--非托管资源释放
qq_24086185的博客
08-01 391
介绍C#非托管资源的释放
C# 中的ArrayPool
yunxiaobaobei的博客
02-22 725
C# 中的ArrayPool
CPU与GPU到底有什么区别？
热门推荐
biyusr的专栏
09-13 1万+
除了这种工作方式之外，GPU的指令集还非常简单，不像CPU这种复杂的处理器，如果你去看CPU的编程手册就会发现，CPU负责的事情非常多：中断处理、内存管理、IO等等，这些对于GPU来说都是不存在的，可以看到GPU的定位非常简单，就是纯计算，GPU绝不是用来取代CPU的，CPU只是把一些GPU非常擅长的事情交给它，GPU仅仅是用来分担CPU工作的配角。你可以简单的将CPU理解为学识渊博的教授，什么都精通，而GPU则是一堆小学生，只会简单的算数运算，可即使教授再神通广大，也不能一秒钟内计算出500次加减法，
c# 调用c++ 动态库 动态数组
06-22
对于单个字母c，它可以有多重含义和用途。作为英文字母表的第三个字母，它常用于拼写英语单词中。例如，它可用于表示“cat”（猫）、“car”（汽车）、“chair”（椅子）等单词的开头。此外，c 还代表不同的概念和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值