Hugo<![CDATA[Isaac's blog]]> 2022-01-17T02:31:29+00:00 https://xie.rocks/ <![CDATA[C#内存相关类型理解]]> https://xie.rocks/posts/system-memory/ 2021-07-30T10:05:46+08:00 2022-01-17T10:30:16+08:00 memory access pattern

In .NET world, there are three types of memory you may be interested:

  1. Managed heap memory, such as an array;
  2. Stack memory, such as objects created by stackalloc;
  3. Native memory, such as a native pointer reference.

Each type of memory access may need to use language features that are designed for it:

To access heap memory, use the fixed (pinned) pointer on supported types (like string), or use other appropriate .NET types that have access to it, such as an array or a buffer; To access stack memory, use pointers with stackalloc; To access unmanaged system memory, use pointers with Marshal APIs. You see, different access pattern needs different code, no single built-in type for all contiguous memory access.

System.Memory<T>

readonly struct Memory<T> : IEquatable<Memory<T>>
{
    // The highest order bit of _index is used to discern whether _object is a pre-pinned array.
    // (_index < 0) => _object is a pre-pinned array, so Pin() will not allocate a new GCHandle
    //       (else) => Pin() needs to allocate a new GCHandle to pin the object.
    private readonly object? _object;
    private readonly int _index;
    private readonly int _length;
}

注解

与 Span 类似， Memory 表示一段连续的内存。 不同点在于 Memory 不是 ref struct。 这意味着， Memory 可以放置在托管堆上，而 Span 不能。 因此，Memory 没有 Span 的那些限制。 具体而言：

  • 它可用作类中的字段。
  • 它可以跨 await 和 yield 边界使用 。 除了Memory之外 ，还可以使用 System.ReadOnlyMemory 来表示不可变或只读内存。

object可以是：

  1. T[]
  2. MemoryManager<T>
  3. T=char && object=string
  4. T=byte/Char8 && object=Utf8String

隐式转换：

  1. ArraySegment<T> to Memory<T>
  2. Memory<T> to ReadOnlyMemory<T>
  3. T[] to Memory<T>

ArraySegment<T>

表示一维数组中的一段区域

readonly struct ArraySegment<T> : IList<T>, IReadOnlyList<T>
{
    private readonly T[]? _array;
    private readonly int _offset; 
    private readonly int _count;
}

MemoryManager<T>

MemoryManager 是一个抽象基类，实现 MemoryManager 的类型可以达到替换 Memory 作用。

abstract class MemoryManager<T> : IMemoryOwner<T>, IPinnable
{
    public virtual Memory<T> Memory => new Memory<T>(this, GetSpan().Length);
    public abstract Span<T> GetSpan();
    public abstract MemoryHandle Pin(int elementIndex = 0);
    public abstract void Unpin();

    protected Memory<T> CreateMemory(int length) => new Memory<T>(this, length);
    protected Memory<T> CreateMemory(int start, int length) => new Memory<T>(this, start, length);
    protected internal virtual bool TryGetArray(out ArraySegment<T> segment);
}

ref struct

ref struct是仅在堆栈上的值类型(也被称为嵌入式引用)：

  1. 表现一个顺序结构的布局；（译注：可以理解为连续内存）
  2. 只能在堆栈上使用 (stack only) 。即用作方法参数和局部变量；
  3. 不能是类或正常结构的静态或实例成员；
  4. 不能是异步方法或lambda表达式的方法参数；
  5. 不能动态绑定、装箱、拆箱、包装或转换。

Span<T>

类型安全和内存安全地表示一段连续内存，它是一个ref struct， 只能在stack上分配内存, 而不能在heap上分配内存, 但是它的实例可以指向托管内存、原生内存或者栈上内存

readonly ref struct Span<T>
{
    internal readonly ByReference<T> _pointer;
    private readonly int _length;
}
]]> <![CDATA[手机连接windows共享文件夹]]> https://xie.rocks/posts/windows-share/ 2021-01-24T17:49:00+08:00 2022-01-17T10:30:16+08:00 长期以来，手机和PC的文件互传能力总是不太令人满意，虽然国产手机厂商在这方面做一了一些努力，但是个人感觉还是不尽如意，并且不够通用。 其实有一个通用的方案，就是SMB协议，ios和android可以通过smb协议连接windows的共享文件夹。iOS13已经原生支持了SMB协议，Android也只需要下载一个SMB客户端就行。

设置windows共享文件夹

新建windows本地账户

本人经过多次尝试，发现使用微软在线账号来连接widnows共享文件夹总会失败，原因未知。使用本地账户一次就连上了。

在开始菜单搜索“计算机管理”，并打开计算机管理，切到本地用户和组，进入用户选项卡，然后右键菜单选中新建用户。

这是图片

设置windows共享文件夹

这是图片 这是图片 这是图片

设置共享文件夹权限

这是图片 这是图片 这是图片

设置iPhone连接

这是图片 这是图片 这是图片 这是图片

设置Android AndSMB客户端连接

这是图片 这是图片

]]> <![CDATA[面试题汇总]]> https://xie.rocks/posts/%E9%9D%A2%E8%AF%95%E9%A2%98%E6%B1%87%E6%80%BB/ 2021-01-21T23:14:12+08:00 2021-01-21T23:14:12+08:00 最近参加了数十个公司的后台开发岗位面试，有些面试官问到了一些有意思的题目，个人觉得有必要记录下来，方便以后面试复习。

题目列表

  1. 任务系统复杂度体现在哪里？

    1. 配置规模大，2300 多行，66 列的配置
    2. 玩家实际接取的任务数量多，超过 500 多个任务。
    3. 代码量多，15000 行左右的代码，
    4. 支持任务目标多，超过 100 多种不同的任务目标
    5. 大量被其他系统所引用，超过 90 个代码文件里面引用了任务系统

  2. lua metatable 的用处

  3. C++ 多态 虚函数机制介绍

  4. 二叉树遍历

    • 按遍历顺序分为：前序，中序，后序
    • 按实现方式：递归，循环+栈数据结构，Morris Traversal

  5. stl shuffle的实现

    template< class RandomIt >
    void random_shuffle( RandomIt first, RandomIt last )
    {
        typename std::iterator_traits<RandomIt>::difference_type i, n;
        n = last - first;
        for (i = n-1; i > 0; --i) {
            std::swap(first[i], first[std::rand() % (i+1)]);
        }
    }
    //来自 <https://en.cppreference.com/w/cpp/algorithm/random_shuffle>

  1. 多线程开发需要注意的点？

    • 能不用就不用。单线程程序易写易调易维护。如果决定采用多线程，想清楚收益，最好能预估
    • 尽量不共享数据
    • 如果要共享数据，Go 不要以共享内存的方式来通信，相反，要通过通信来共享内存
    • 如果要共享数据
      • 如果只是一些简单数据共享，还可以使用原子类型。（如计算变量之类的）
      • 如果一定需要自定义临界区，尽量使用互斥锁 mutex, 多读少写的情况下使用读写锁，理顺锁的顺序避免死锁发生

  2. 如何避免死锁？

    • 线程之间交错执行
      • 解决：以固定的顺序加锁
    • 执行某方法时就需要持有锁，且不释放
      • 解决：缩减同步代码块范围，最好仅操作共享变量时才加锁
    • 永久等待
      • 解决：使用 tryLock()定时锁，超过时限则返回错误信息

  3. 出现死锁怎么检测？

    • 检测有向图是否存在环，从一个节点出发深度优化搜索，对访问过的节点进行标记，如果访问了已标记的节点，就表示有向图存在环。

  4. 条件变量用来干什么的

    • 条件变量是线程可用的一种同步机制，条件变量给多个线程提供一个回合的场所。条件变量与互斥量一次使用，允许线程以无竞争的方式等待一个特定的条件发生。

  5. redis 基础数据结构介绍？

  6. 红黑树和跳跃表比较

    1. 时间复杂度差不多，跳跃表实现简单，方便调试和 review
    2. 跳跃表范围查找更方便（因为有 next 指针）
    3. 跳跃表并发支持更好，红黑树插入删除有 rebalance 的过程，会涉及到比较多的节点，而跳跃表因为是链表结构，并发加锁的粒度就会小一些，并发支持就更友好一些。

  7. 自己的优势？

    • 肯专研，喜欢去看源码
    • 喜欢去接触新的技术，或者是提高工作效率的东西

  8. 自己的劣势？ *比较好说话了，不够强势。

  9. 挑战最大的事情？怎么解决的？

  10. 缓存一致性

  11. 扩容

  12. 缩容

  13. 单点

  14. 故障自愈

  15. 并发量大处理不过来怎么办？

  16. epoll 与 select 区别

  17. 进程与线程调度区别？

  18. 大数相乘的实现

  19. 格子最短路径数统计

  20. 背包问题

  21. 排行榜服务器实现 （上榜、下榜逻辑）

  22. 好友服务器实现 （添加好友、删除好友逻辑）

  23. 匹配服务器实现，以及如何选战斗服务器（ds)

  24. 有序数组去除重复元素

  25. 链表，将倒数 K 个节点，移到链表前面

]]>