Question

class myclass 
{
    private Semaphore _sync;

    myclass ()
    {
          _sync = new Semaphore(1,1);
    }

    doasync()
    {
           _sync.WaitOne();
           //do some stuff
           _sync.Release();
    }
}


 somefunctionsomewhere() 
 {
     var myobject = new myclass();    
     //spawn 100 threads that all call myobject.doasync()
 }

以上安全+清洁？当所有100个线程完成异步工作时，是否会释放_sync并收集myclass？

如果没有，知道何时调用_sync.Dispose（）的最佳方式是什么？

Answer 1

简答：不，你不需要调用Dispose（）。

答案很长：

虽然建议在使用完信号量后调用Dispose（），但垃圾收集器迟早会处理信号量的资源。

对Dispose（）的显式调用将保证关联资源的早期发布，但只有在短时间内创建并忘记大量Semaphore实例时才需要它。 / p>

如果你调用Dispose（），使用简单的Dispose（）调用就可以了。您不需要创建终结器~myclass()，因为这只会复制已经完成信号量实现的内容。

Answer 2

如果一个类实现了IDisposable，你真的应该正确处理它。它不仅仅依赖于垃圾收集器，一次性类可以有打开的句柄/ COM对象，需要正确清理，不能保证GC能够处理。

理想情况下，您应该使myclass实现IDisposable并在dispose方法中清理您的一次性对象。如果您确实无法确定何时处置myclass实例，则可以在析构函数方法中为myclass实现逻辑以调用dispose方法。

public class myclass : IDisposable
   {
   private Semaphore _sync;

    myclass ()
    {
          _sync = new Semaphore(1,1);
    }

    doasync()
    {
           _sync.WaitOne();
           //do some stuff
           _sync.Release();
    }

    public void Dispose()
       Dispose(true);
       GC.SuppressFinalize(this);
    {

    protected void Dispose(bool isDisposing)
    {
       var sync=Interlocked.Exchange(ref _sync,null);
       if (sync !=null) sync.Dispose();
    }


    // This is for when you cannot determine when to dispose of your object
    void ~myclass() {
       Dispose(false);
    }
}

是否有必要在信号量上调用Dispose？

2 个答案: