安全地提升事件线程 - 最佳实践

Question

为了引发事件,我们使用OnEventName方法,如下所示:

protected virtual void OnSomethingHappened(EventArgs e) 
{
    EventHandler handler = SomethingHappened;
    if (handler != null) 
    {
        handler(this, e);
    }
}

但这个有什么不同？

protected virtual void OnSomethingHappened(EventArgs e) 
{
    if (SomethingHappened!= null) 
    {
        SomethingHappened(this, e);
    }
}

显然第一个是线程安全的,但为什么以及如何？

没有必要开始一个新线程？

Answer 1

有一个微小的机会SomethingHappened成为null空校验之后,但在调用之前.然而,MulticastDelagates为不可变的,所以如果你第一次分配一个变量,空检查依据的变量,并通过它调用,你是从场景中安全(自我插头:我写了一个博客张贴关于这一段时间以前).

虽然有硬币的背面; 如果使用临时变量方法,则代码受NullReferenceExceptions 保护,但可能是事件将在事件分离后调用事件侦听器.这只是以最优雅的方式处理的事情.

为了解决这个问题,我有一个有时使用的扩展方法:

public static class EventHandlerExtensions
{
    public static void SafeInvoke<T>(this EventHandler<T> evt, object sender, T e) where T : EventArgs
    {
        if (evt != null)
        {
            evt(sender, e);
        }
    }
}

使用该方法,您可以调用以下事件:

protected void OnSomeEvent(EventArgs e)
{
    SomeEvent.SafeInvoke(this, e);
}

Answer 2

从C#6.0开始,您可以使用monadic Null-conditional运算符?.来检查null并以简单且线程安全的方式引发事件.

SomethingHappened?.Invoke(this, args);

它是线程安全的,因为它只评估左侧一次,并将其保存在临时变量中.您可以在这里阅读更多部分标题为Null-conditional运算符.

更新: 实际上Visual Studio 2015的更新2现在包含重构,以简化委托调用,最终将使用这种类型的表示法.您可以在本公告中阅读相关内容.

Answer 3

我保留这个片段作为设置和触发的安全多线程事件访问的参考:

    /// <summary>
    /// Lock for SomeEvent delegate access.
    /// </summary>
    private readonly object someEventLock = new object();

    /// <summary>
    /// Delegate variable backing the SomeEvent event.
    /// </summary>
    private EventHandler<EventArgs> someEvent;

    /// <summary>
    /// Description for the event.
    /// </summary>
    public event EventHandler<EventArgs> SomeEvent
    {
        add
        {
            lock (this.someEventLock)
            {
                this.someEvent += value;
            }
        }

        remove
        {
            lock (this.someEventLock)
            {
                this.someEvent -= value;
            }
        }
    }

    /// <summary>
    /// Raises the OnSomeEvent event.
    /// </summary>
    public void RaiseEvent()
    {
        this.OnSomeEvent(EventArgs.Empty);
    }

    /// <summary>
    /// Raises the SomeEvent event.
    /// </summary>
    /// <param name="e">The event arguments.</param>
    protected virtual void OnSomeEvent(EventArgs e)
    {
        EventHandler<EventArgs> handler;

        lock (this.someEventLock)
        {
            handler = this.someEvent;
        }

        if (handler != null)
        {
            handler(this, e);
        }
    }

Answer 4

对于.NET 4.5,最好使用它Volatile.Read来分配临时变量.

protected virtual void OnSomethingHappened(EventArgs e) 
{
    EventHandler handler = Volatile.Read(ref SomethingHappened);
    if (handler != null) 
    {
        handler(this, e);
    }
}

更新:

本文对此进行了解释:http://msdn.microsoft.com/en-us/magazine/jj883956.aspx.此外,它在第四版"CLR via C#"中进行了解释.

主要思想是JIT编译器可以优化您的代码并删除本地临时变量.所以这段代码:

protected virtual void OnSomethingHappened(EventArgs e) 
{
    EventHandler handler = SomethingHappened;
    if (handler != null) 
    {
        handler(this, e);
    }
}

将编译成这样:

protected virtual void OnSomethingHappened(EventArgs e) 
{
    if (SomethingHappened != null) 
    {
        SomethingHappened(this, e);
    }
}

这种情况发生在某些特殊情况下,但它可能会发生.

Answer 5

声明这样的事件以获得线程安全:

public event EventHandler<MyEventArgs> SomethingHappened = delegate{};

并像这样调用它:

protected virtual void OnSomethingHappened(MyEventArgs e)   
{  
    SomethingHappened(this, e);
} 

虽然不再需要这种方法..

Answer 6

这取决于线程安全的含义.如果您的定义仅包括预防,NullReferenceException则第一个示例更安全.不过,如果你有一个更严格的定义去该事件处理程序必须进行,如果他们再调用存在既不是安全的.原因与内存模型和障碍的复杂性有关.这可能是有,事实上,事件处理程序链接到委托,但该线程总是读基准为空.修复两者的正确方法是在将委托引用捕获到局部变量的点处创建显式内存屏障.有几种方法可以做到这一点.

• 使用lock关键字(或任何同步机制).
• volatile在事件变量上使用关键字.
• 使用Thread.MemoryBarrier.

尽管尴尬的范围问题阻止你做单行初始化程序,但我仍然更喜欢这种lock方法.

protected virtual void OnSomethingHappened(EventArgs e)           
{          
    EventHandler handler;
    lock (this)
    {
      handler = SomethingHappened;
    }
    if (handler != null)           
    {          
        handler(this, e);          
    }          
}          

需要注意的是,在这种特定的情况下,内存屏障问题很可能是没有实际意义,因为它是不太可能的变数,将读取外面的方法调用被取消是很重要的.但是,如果编译器决定内联该方法,则没有任何保证.