首页 > > 网络编程 > Asp.Net编程 >

优化字符串拼接之二:非托管内存应用

2018-06-22 06:32:53来源：未知阅读 ()

前(tu)言(cao)

　　之前一篇虽然也强调了,可是回复中还是有人来挑刺,并且还有人支持?!

#5楼2013-08-26 21:39

楼主看下StringBuilder的makeroom方法吧。微软官方的，有些东西不是人家做不到，而是人家考虑的更多。

　　所以我不得不再次强调一下,系统是考虑的很多,但是我不需要这么多功能可以吗?我只希望他快一点,(对我来说)更好用一点.

　　就好比,如果你只想拧螺丝,你会选择瑞士军刀,还是选择螺丝刀?! 你见过多少维修师傅带着一把瑞士军刀去你家修东西的?

　　当维修师傅拿出一把螺丝刀,并且觉得非常好用的时候,难道你对他说,瑞士军刀也能拧螺丝,为什么你带螺丝刀,你真是弱爆了!!

我只是想我的字符串拼接快一点,至于其他功能,暂时我不需要!谢谢

对上一篇的简述

　　上一篇中的主要思路就是,参照StringBuilder中Append的重载,自己写一个新的对象,保证每一个Append方法都比StringBuilder更快就好了(实际上有部分是达不到这个要求的,但是能保证大部分快,一部分相同,1,2慢一些,整体上来说就能达到我的要求了)

　　并且在上一篇中有一个缓冲区的概念,是一个Char数组,当字符串超过缓冲区大小之后,将重新申请新的char数组,比原先的大一倍,并将原先的字符串赋值到新数组(这里成了新的一个瓶颈点)

　　上一篇(精简版StringBuilder,提速字符串拼接)链接在此,没看过的可以先移步去看一下

应用

　　很多人说,节省这么点时间有什么用,我觉得这个观点本身就是错误的,古语有云:不积跬步无以至千里,不积小流无以成江海;

　　好吧又有很多人会说在放屁了,下面说个实例;

　　在我的Json组件中,下面有一组ObjectToJsonString的时间测试,(这次我没有拿千万次,百万次来测试)

//======= StringBuilder  =========================================================================
======= 一万次 单个实体 ===
 运行时间    CPU时钟周期    垃圾回收( 1代      2代      3代 )
 1,367ms     2,708,098,820            358      0        0
======= 一千次 实体集合 ===
 运行时间    CPU时钟周期    垃圾回收( 1代      2代      3代 )
 1,256ms     2,479,181,117            129      0        0
 
//======= 优化前  ================================================================================
======= 一万次 单个实体 ===
 运行时间    CPU时钟周期    垃圾回收( 1代      2代      3代 )
 1,089ms     2,170,463,778            350      0        0
======= 一千次 实体集合 ===
 运行时间    CPU时钟周期    垃圾回收( 1代      2代      3代 )
 802ms       1,565,483,218            140      0        0

　　其中单个实体是一个拥有15个左右属性的实体 . 实体集合是 200个实体对象每个实体 5个属性,从上面可以看出一些性能的差异,至于到底值不值得,就仁者见仁了

　　所以这个类设计之后被我应用到了很多地方,几乎所有的StringBuilder都可以用这个代替(我是说几乎,不是全部)

优化扩容操作

　　刚才中有提到缓冲区在扩容的时候是一个性能瓶颈,其中有2个操作,1申请新的数组,2将原有数据拷贝到新数组中,这个拷贝的操作将是十分耗时的;所以我第一想到的就是不拷贝,仅申请一个新数组,不够的话再申请一个,直到最后的ToString 再把所有char数组合并 String.Concat

　　最终定下一个方案,仅在初始化时开辟一个8长度的String数组buffer作为二级缓冲,当一级缓冲char数组满了之后,把二级缓冲 string.Concat(buffer) 组成一个新的字符串,放入buffer[0],其他清空,这样就可以规避一些拷贝数据带来的性能损失

内存指针操作数组

　　字符串操作,其实就是在操作Char数组, 说到数组的操作很多人会想到指针,没错数组操作,使用指针定位会比索引取值要快很多,但是.NET中指针操作被成为是"不安全代码",因为微软告诉我们

指向可移动托管变量的指针的作用很小，因为垃圾回收可能不可预知地重定位变量。

　　这就意味着一旦发生垃圾回收,你的指针指向的对象就有可能已经不是原来的对象了

　　比如:当我正在操作char数组的时候我的指针指向 char数组的第10位 char* p = (char*)char[]; p[10]但是由于垃圾回收,当我得到p的时候 char[]被重新安排在内存的另外一个地方了,但是p并没有改变,那么p[10]所获取或设置的值,就已经不是原来char数组的值了

　　当然微软也有办法解决,其中fixed是一种方式:

char[] buffer = new char[100];
fixed (char* p = buffer)
{
    p[10] = 'a';
    //....
}

　　这样确实可以固定这个对象,保证不因为垃圾回收而改变内存位置,但是这是一个方法级的语块;这就意味着你无法固定一个类的字段,想想我们有那么多的Append方法,不可能每个方法都固定一次(fixed也是有性能损失的)

　　另外一个方法就是申请非托管内存,所谓非托管,也就是说垃圾回收将不处理这块内存, 所以这也意味着,你可以不用担心GC来捣乱,但是需要自己去释放它,不过是小问题;

非托管内存

　　申请非托管内存很简单,参考MSDN

//生成字符串缓冲区指针 ,一个char是2个字节,所以要乘以2
IntPtr _currIntPtr = System.Runtime.InteropServices.Marshal.AllocHGlobal(size * 2);
char* _current = (char*)_currIntPtr.ToPointer();

　　当然用完要记得释放,这个就实现IDisposable

　　还有一点需要注意的就是这个方法是不能重复执行的,会报错,所以需要判断一下

private int _disposeMark = 0;

public void Dispose()
{
    var mark = System.Threading.Interlocked.Exchange(ref _disposeMark, 1);
    if (mark == 1)
    {
        return;
    }
    System.Runtime.InteropServices.Marshal.FreeHGlobal(_currIntPtr);
    GC.SuppressFinalize(this);
}

代码优化

　　把以上2点结合起来,就有了以下代码

        /// <summary> 指针句柄
        /// </summary>
        private readonly IntPtr _currIntPtr;
        /// <summary> 一级缓冲指针
        /// </summary>
        private char* _current;
        /// <summary> 二级缓冲
        /// </summary>
        readonly string[] _buffer = new string[8];
        /// <summary> 备用二级缓冲索引
        /// </summary>
        int _bufferIndex;
        /// <summary> 总字符数
        /// </summary>
        int _length;
        /// <summary> 结束位,一级缓冲长度减一
        /// </summary>
        int _endPosition;
        /// <summary> 一级缓冲当前位置
        /// </summary>
        int _position;

        /// <summary> 初始化对象,并指定缓冲区大小
        /// </summary>
        /// <param name="size"></param>
        public QuickStringWriter(ushort size)
        {
            //确定最后一个字符的位置  长度-1
            _endPosition = size - 1;
            //生成字符串缓冲指针 ,一个char是2个字节,所以要乘以2
            _currIntPtr = System.Runtime.InteropServices.Marshal.AllocHGlobal(size * 2);
            _current = (char*)_currIntPtr.ToPointer();
        }

构造函数

        /// <summary> 获取当前实例中的字符串总长度
        /// </summary>
        public int Length
        {
            get
            {
                return _length + _position;
            }
        }

Length

        /// <summary> 尝试在一级缓冲区写入一个字符
        /// <para>如果一级缓冲区已满,将会自动调用Flush方法转移一级缓冲区中的内容</para>
        /// </summary>
        private void TryWrite()
        {
            if (_position > _endPosition)
            {
                Flush();
            }
            else if (_endPosition == int.MaxValue)
            {
                throw new Exception("指针尚未准备就绪!");
            }
        }
        /// <summary> 尝试在一级缓冲区写入指定数量的字符
        /// </summary>
        /// <para>如果尝试写入的字符数大于一级缓冲区的大小,返回false</para>
        /// <para>如果尝试写入的字符数超出一级缓冲区剩余容量,自动调用Flush方法</para>
        /// <param name="count">尝试写入的字符数</param>
        /// <returns></returns>
        private bool TryWrite(int count)
        {
            if (count >= _endPosition)
            {
                return false;
            }
            var pre = _position + count;
            if (pre >= _endPosition)
            {
                Flush();
            }
            else if (_endPosition == int.MaxValue)
            {
                throw new Exception("指针尚未准备就绪!");
            }
            return true;
        }

TryWrite

        /// <summary> 清理当前实例的一级缓冲区的内容，使所有缓冲数据写入二级缓冲区。
        /// </summary>
        public void Flush()
        {
            if (_position > 0)
            {
                _length += _position;
                if (_bufferIndex == 8)
                {
                    _buffer[0] = string.Concat(_buffer);
                    _buffer[1] = new string(_current, 0, _position);
                    _buffer[2] =
                    _buffer[3] =
                    _buffer[4] =
                    _buffer[5] =
                    _buffer[6] =
                    _buffer[7] = null;
                    _bufferIndex = 2;
                }
                else
                {
                    _buffer[_bufferIndex++] = new string(_current, 0, _position);
                }
                _position = 0;
            }
        }

Flush

        /// <summary> 返回当前实例中的字符串
        /// </summary>
        public override string ToString()
        {
            if (_bufferIndex == 0)
            {
                return new string(_current, 0, _position);
            }
            if (_bufferIndex <= 3)
            {
                return string.Concat(_buffer[0], _buffer[1], _buffer[2], new string(_current, 0, _position));
            }
            return string.Concat(_buffer[0], _buffer[1], _buffer[2], _buffer[3],
                                 _buffer[4], _buffer[5], _buffer[6], _buffer[7],
                                 new string(_current, 0, _position));
        }

ToString

其他一些优化

        private static char HexToChar(int a)
        {
            a &= 15;
            return a > 9 ? (char)(a - 10 + 0x61) : (char)(a + 0x30);
        }

        /// <summary> 将 Guid 对象转换为字符串追加到当前实例。
        /// </summary>
        public QuickStringWriter Append(Guid val, char format = 'd')
        {
            int flag;
            switch (format)
            {
                case 'd':
                case 'D':
                    flag = 1;
                    TryWrite(36);
                    break;
                case 'N':
                case 'n':
                    flag = 0;
                    TryWrite(32);
                    break;
                case 'P':
                case 'p':
                    TryWrite(38);
                    _current[_position++] = '(';
                    flag = ')';
                    break;
                case 'B':
                case 'b':
                    TryWrite(38);
                    _current[_position++] = '{';
                    flag = '}';
                    break;
                default:
                    Append(val.ToString(format.ToString()));
                    return this;
            }
            var bs = val.ToByteArray();
            _current[_position++] = HexToChar(bs[3] >> 4);
            _current[_position++] = HexToChar(bs[3]);
            _current[_position++] = HexToChar(bs[2] >> 4);
            _current[_position++] = HexToChar(bs[2]);
            _current[_position++] = HexToChar(bs[1] >> 4);
            _current[_position++] = HexToChar(bs[1]);
            _current[_position++] = HexToChar(bs[0] >> 4);
            _current[_position++] = HexToChar(bs[0]);
            if (flag > 0)
            {
                _current[_position++] = '-';
            }
            _current[_position++] = HexToChar(bs[5] >> 4);
            _current[_position++] = HexToChar(bs[5]);
            _current[_position++] = HexToChar(bs[4] >> 4);
            _current[_position++] = HexToChar(bs[4]);
            if (flag > 0)
            {
                _current[_position++] = '-';
            }
            _current[_position++] = HexToChar(bs[7] >> 4);
            _current[_position++] = HexToChar(bs[7]);
            _current[_position++] = HexToChar(bs[6] >> 4);
            _current[_position++] = HexToChar(bs[6]);
            if (flag > 0)
            {
                _current[_position++] = '-';
            }
            _current[_position++] = HexToChar(bs[8] >> 4);
            _current[_position++] = HexToChar(bs[8]);
            _current[_position++] = HexToChar(bs[9] >> 4);
            _current[_position++] = HexToChar(bs[9]);
            if (flag > 0)
            {
                _current[_position++] = '-';
            }
            _current[_position++] = HexToChar(bs[10] >> 4);
            _current[_position++] = HexToChar(bs[10]);
            _current[_position++] = HexToChar(bs[11] >> 4);
            _current[_position++] = HexToChar(bs[11]);
            _current[_position++] = HexToChar(bs[12] >> 4);
            _current[_position++] = HexToChar(bs[12]);
            _current[_position++] = HexToChar(bs[13] >> 4);
            _current[_position++] = HexToChar(bs[13]);
            _current[_position++] = HexToChar(bs[14] >> 4);
            _current[_position++] = HexToChar(bs[14]);
            _current[_position++] = HexToChar(bs[15] >> 4);
            _current[_position++] = HexToChar(bs[15]);
            if (flag > 1)
            {
                _current[_position++] = (char)flag;
            }
            return this;
        }

Append(Guid val)

        /// <summary> 将 Int64 对象转换为字符串追加到当前实例。
        /// </summary>
        public QuickStringWriter Append(Int64 val)
        {
            if (val == 0)
            {
                TryWrite();
                _current[_position++] = '0';
                return this;
            }

            var zero = (long)'0';

            var pos = 19;
            var f = val < 0;
            if (f)
            {
                _number[pos] = (char)(~(val % 10L) + (long)'1');
                if (val < -10)
                {
                    val = val / -10;
                    _number[--pos] = (char)(val % 10L + zero);
                }
            }
            else
            {
                _number[pos] = (char)(val % 10L + zero);
            }
            while ((val = val / 10L) != 0L)
            {
                _number[--pos] = (char)(val % 10L + zero);
            }
            if (f)
            {
                _number[--pos] = '-';
            }
            var length = 20 - pos;
            Append(_number, pos, length);
            return this;
        }

Append(Number val)

/// <summary> 将内存中的字符串追加到当前实例。
        /// </summary>
        /// <param name="point">内存指针</param>
        /// <param name="offset">指针偏移量</param>
        /// <param name="length">字符长度</param>
        /// <returns></returns>
        public QuickStringWriter Append(char* point, int offset, int length)
        {
            if (length > 0)
            {
                if (TryWrite(length))
                {
                    char* c = point + offset;
                    if ((length & 1) != 0)
                    {
                        _current[_position++] = c[0];
                        c++;
                        length--;
                    }
                    int* p1 = (int*)&_current[_position];
                    int* p2 = ((int*)c);
                    _position += length;
                    while (length >= 8)
                    {
                        (*p1++) = *(p2++);
                        (*p1++) = *(p2++);
                        (*p1++) = *(p2++);
                        (*p1++) = *(p2++);
                        length -= 8;
                    }
                    if ((length & 4) != 0)
                    {
                        (*p1++) = *(p2++);
                        (*p1++) = *(p2++);
                    }
                    if ((length & 2) != 0)
                    {
                        (*p1) = *(p2);
                    }
                }
                else
                {
                    Flush();
                    _buffer[_bufferIndex++] = new string(point, offset, length);
                    _length += length;
                }
            }

            return this;
        }

Append(char* point, int offset, int length)

优化后的性能对比

　　依然使用 ObjectToJsonString 来做对比

//======= StringBuilder  =========================================================================
======= 一万次 单个实体 ===
 运行时间    CPU时钟周期    垃圾回收( 1代      2代      3代 )
 1,367ms     2,708,098,820            358      0        0
======= 一千次 实体集合 ===
 运行时间    CPU时钟周期    垃圾回收( 1代      2代      3代 )
 1,256ms     2,479,181,117            129      0        0
 
//======= 优化前  ================================================================================
======= 一万次 单个实体 ===
 运行时间    CPU时钟周期    垃圾回收( 1代      2代      3代 )
 1,089ms     2,170,463,778            350      0        0
======= 一千次 实体集合 ===
 运行时间    CPU时钟周期    垃圾回收( 1代      2代      3代 )
 802ms       1,565,483,218            140      0        0

//======= 优化后  ================================================================================
======= 一万次 单个实体 ===
 运行时间    CPU时钟周期    垃圾回收( 1代      2代      3代 )
 688ms       1,353,917,147            52       0        0
======= 一千次 实体集合 ===
 运行时间    CPU时钟周期    垃圾回收( 1代      2代      3代 )
 663ms       1,322,653,932            78       0        0