.NET 中的 Erlang 风格的轻量级进程

Question

有没有办法在.NET中实现Erlang风格的轻量级进程？

我发现了一些实现 Erlang 消息传递模型（参与者模型）的项目。例如，Axum。但我没有发现任何关于轻量级流程实施的信息。我的意思是在单个操作系统线程或操作系统进程的上下文中运行的多个进程。

Answer 1

我认为 F# MailboxProcessor 就是您正在寻找的 Alexey。使用 MailboxProcessor，您可以在一个 .NET 进程中定义数以万计的代理，就像您可以在 Erlang 中生成数以万计的轻量级进程一样。

这个MSDN 帖子 是一个很好的介绍。

如果您是从 Erlang 背景转向 .NET 的，请记住，您将错过很多 OTP 的好处（管理器、位置透明性、mnesia，...）。

Answer 2

CLR 可以被托管并公开主机实现其自己的任务抽象的机制。理论上，它们可以是线程、光纤、LWP - 只要主机实现 必要的 接口。

做到正确有点困难。 MS 抓住了这个机会，以 SQL Server Fiber 模式托管 CLR。

在最后一刻，出现了一些压力错误，因此他们根据 乔·达菲和迪诺·维兰德（谁运行了在他的博客上编写了一个自定义 CLR 主机，该主机通过纤程实现了自己的任务抽象）。< br>
现在缺少一些管道 - ICLRTask::SwitchOut()- 即使有人解决了这个问题，在压力测试迭代中攻击 MS 的相同错误也可能会困扰着冒险的灵魂。

假设所有问题都以某种方式得到解决，并且整个运行时已准备好在纤程、LWP 等上运行。 P/Invoke 仍然存在可能调用阻塞操作的问题。如果没有内核的支持，这种调度是很难做到的。

64 位版本的 Windows 7 和 Windows 2008 Server R2 已解决此问题。现在有用户模式调度可以产生如果调用在内核中阻塞，则控制权返回到用户模式 - 与内核模式相反 - 调度程序。此外，这些用户模式调度线程是具有自己的 TLS 的真实线程。这些都是巨大的改进，使许多光纤模式令人头痛的问题迎刃而解。

目前，使用 UMS< /a> 在 并发运行时 中 < a href="http://msdn.microsoft.com/en-us/library/dd504870(VS.100).aspx" rel="noreferrer">可用于 C++，是 C 运行时库 (CRT) 的一部分< /a>.
后者意味着您可以在 Visual Studio 2010 中直接使用它。

Answer 3

您看过 retlang 吗？我只读过它，但我没有用它做任何事情，但是......

Answer 4

Erlang进程就像并行运行方法，但是erlang变量只能绑定一次，因此它是线程安全的，而C#中则没有。

所以在 C# 中你需要两件事：线程安全和并行。

C#有System.Threading.Task，可以在vm中运行很多任务。 C# vm 将在不同的工作线程中调度这些任务。

但是任务不是线程安全的，你需要创建一个名为Actor的类，并将状态放在Actor中私有。

Actor 有一个 System.Threading.SynchronizationContext 和许多异步方法，就像这样。

class Actor {
  public SynchronizationContext _context;

  private int value1;
  private Dictionary<> xxx;
  private List<> xxx;


  public async Task Method1() {
      await _context;

      doSomething();
  }

}

当其他Actor调用该Actor中的async方法时，会创建一个任务，该任务将由vm调度。

您还需要实现一个可等待且线程安全的 SynchronizationContext。

这是一个线程安全的上下文。

public class ActorSynchronizationContext : SynchronizationContext
{
    private readonly SynchronizationContext _subContext;
    private readonly ConcurrentQueue<Action> _pending = new ConcurrentQueue<Action>();
    private int _pendingCount;

    public ActorSynchronizationContext(SynchronizationContext context = null)
    {
        this._subContext = context ?? new SynchronizationContext();
    }

    public override void Post(SendOrPostCallback d, object state)
    {
        if (d == null) {
            throw new ArgumentNullException("SendOrPostCallback");
        }
        _pending.Enqueue(() => d(state));
        if (Interlocked.Increment(ref _pendingCount) == 1)
        {
            try
            {
                _subContext.Post(Consume, null); 
            }
            catch (Exception exp)
            {
                LogHelper.LogUnhandleException(exp.ToString());
            }
        }
    }

    private void Consume(object state)
    {
        var surroundContext = Current;
        SetSynchronizationContext(this);
        do
        {
            Action a;
            _pending.TryDequeue(out a);
            try
            {
                a.Invoke();
            }
            catch (Exception exp)
            {
                //Debug.LogError(exp.ToString());
                LogHelper.LogUnhandleException(exp.ToString());
            }
        } while (Interlocked.Decrement(ref _pendingCount) > 0);
        SetSynchronizationContext(surroundContext);
    }

    public override void Send(SendOrPostCallback d, object state)
    {
        throw new NotSupportedException();
    }
    public override SynchronizationContext CreateCopy()
    {
        return this;
    }
}

让 SynchroniztionContext 可等待

public static class SynchroniztionContextExtensions
{
    public static SynchronizationContextAwaiter GetAwaiter (this   SynchronizationContext context) 
    {
        if(context == null) throw new ArgumentNullException("context");
        return new SynchronizationContextAwaiter(context);
    }
}

SynchronizationContext 的 Awaiter

public sealed class SynchronizationContextAwaiter : INotifyCompletion
{
    private readonly SynchronizationContext _context;
    public SynchronizationContextAwaiter(SynchronizationContext context)
    {
        if(context == null ) throw new ArgumentNullException("context");
        _context = context;
    }
    public bool IsCompleted {
        get
        {
            //已经在当前上下文里面了，就不需要再次切换上下文
            return SynchronizationContext.Current == _context;
        }
    }

    /// <summary>
    /// 将Action 任务调度到 _context 控制的线程里面去执行
    /// 
    /// var temp = e.GetAwaiter();
    /// </summary>
    /// <param name="action">Action.</param>
    public void OnCompleted(Action action) {
        _context.Post(x=>action(), null);
    }
    public void GetResult(){}
} 

然后你会得到一个具有任务和线程安全的 Actor 类，就像 erlang 中的进程一样。

Answer 5

这毫无意义。 “在单个操作系统线程或操作系统进程的上下文中运行的多个进程”在逻辑上是没有结论的。这基本上是一个逻辑应用程序级别的事情 - 您可以轻松地在 .NET 中重现它。但在操作系统级别上不存在“进程中的进程”之类的东西。