NET里面的跨线程/进程同步

     线程/进程间的通讯需要共享内存或者其他内建机制来发送/接收数据。即使是采用共享内存的方式，也还需要一组同步方法来允许并发访问。

     同一个进程内的所有线程都共享公共的逻辑地址空间（堆）； 但对于不同进程，从 win2000 开始就已经无法共享内存。然而，不同的进程可以读写同一个文件。WinAPI提供了多种系统调用方法来映射文件到进程的逻辑空间，及访问系统内核对象（会话）指向的 pagefile 里面的虚拟文件。

     无论是共享堆，还是共享文件，并发访问都有可能导致数据不一致。我们就这个问题简单讨论一下，该怎样确保线程/进程调用的有序性及数据的一致性。 

1、线程同步

.NET 框架和 C# 提供了方便直观的线程同步方法，即 monitor 类和 lock 语句（本文将不会讨论 .NET 框架的互斥量）。对于线程同步，虽然本文提供了其他方法，我们还是推荐使用 lock 语句。

void Work1()
{
  NonCriticalSection1();
  Monitor.Enter(this);
  try
  {
    CriticalSection();
  }
  finally
  {
    Monitor.Exit(this);
  }
  NonCriticalSection2();
}

void Work2()
{
  NonCriticalSection1();
  lock(this)
  {
    CriticalSection();
  }
  NonCriticalSection2();
}

　注意：Work1 和 Work2 是等价的。在C#里面，很多人喜欢第二个方法，因为它更短，且不容易出错。

 

2、跨线程信号量

     信号量是经典的同步基本概念之一（由 Edsger Dijkstra 引入）。信号量是指一个有计数器及两个操作的对象。它的两个操作是：获取（也叫P或者等待），释放（也叫V或者收到信号）。信号量在获取操作时如果计数器为0则阻塞，否则将计数器减一；在释放时将计数器加一，且不会阻塞。虽然信号量的原理很简单，但是实现起来有点麻烦。好在，内建的monitor 类有阻塞特性，可以用来实现信号量。

    

public sealed class ThreadSemaphore : ISemaphore
{
  private int counter;
  private readonly int max;
 
  public ThreadSemaphore() : this(0, int.Max) {}
  public ThreadSemaphore(int initial) : this(initial, int.Max) {}
  public ThreadSemaphore(int initial, int max)
  {
    this.counter = Math.Min(initial,max);
    this.max = max;
  }
 
  public void Acquire()
  {
    lock(this)
    {
      counter--;
      if(counter < 0 && !Monitor.Wait(this))
        throw new SemaphoreFailedException();
    }
  }
 
  public void Acquire(TimeSpan timeout)
  {
    lock(this)
    {
      counter--;
      if(counter < 0 && !Monitor.Wait(this,timeout))
        throw new SemaphoreFailedException();
    }
  }
 
  public void Release()
  {
    lock(this)
    {
      if(counter >= max)
        throw new SemaphoreFailedException();
      if(counter < 0)
        Monitor.Pulse(this);
      counter++;
    }
  }
}

　　信号量在复杂的阻塞情景下更加有用，例如我们后面将要讨论的通道（channel）。你也可以使用信号量来实现临界区的排他性（如下面的 Work3），但是我还是推荐使用内建的 lock 语句，像上面的 Work2 那样。

      请注意：如果使用不当，信号量也是有潜在危险的。正确的做法是：当获取信号量失败时，千万不要再调用释放操作；当获取成功时，无论发生了什么错误，都要记得释放信号量。遵循这样的原则，你的同步才是正确的。Work3 中的 finally语句就是为了保证正确释放信号量。注意：获取信号量（ s.Acquire() ）的操作必须放到 try 语句的外面，只有这样，当获取失败时才不会调用释放操作。

ThreadSemaphore s = new ThreadSemaphore(1);
void Work3()
{
  NonCriticalSection1();
  s.Acquire();
  try
  {
    CriticalSection();
  }
  finally
  {
    s.Release();
  }
  NonCriticalSection2();
}

　　

3、跨进程信号量

为了协调不同进程访问同一资源，我们需要用到上面讨论过的概念。很不幸，.NET 中的 monitor 类不可以跨进程使用。但是，win32 API提供的内核信号量对象可以用来实现跨进程同步。 Robin Galloway-Lunn 介绍了怎样将 win32 的信号量映射到 .NET 中（见 Using Win32 Semaphores in C# ）。我们的实现也类似：

[DllImport("kernel32",EntryPoint="CreateSemaphore", SetLastError=true,CharSet=CharSet.Unicode)]
internal static extern uint CreateSemaphore(SecurityAttributes auth, int initialCount,int maximumCount, string name);
 
[DllImport("kernel32",EntryPoint="WaitForSingleObject", SetLastError=true,CharSet=CharSet.Unicode)]
internal static extern uint WaitForSingleObject( uint hHandle, uint dwMilliseconds);
 
[DllImport("kernel32",EntryPoint="ReleaseSemaphore", SetLastError=true,CharSet=CharSet.Unicode)]
[return : MarshalAs( UnmanagedType.VariantBool )]
internal static extern bool ReleaseSemaphore(uint hHandle, int lReleaseCount, out int lpPreviousCount);
     
[DllImport("kernel32",EntryPoint="CloseHandle",SetLastError=true,  CharSet=CharSet.Unicode)]
[return : MarshalAs( UnmanagedType.VariantBool )]
internal static extern bool CloseHandle(uint hHandle);

public class ProcessSemaphore : ISemaphore, IDisposable
{
  private uint handle;
  private readonly uint interruptReactionTime;
 
  public ProcessSemaphore(string name) : this(name,0,int.MaxValue,500) {}
  public ProcessSemaphore(string name, int initial) : this(name,initial,int.MaxValue,500) {}
  public ProcessSemaphore(string name, int initial,int max, int interruptReactionTime)
  {      
    this.interruptReactionTime = (uint)interruptReactionTime;
    this.handle = NTKernel.CreateSemaphore(null, initial, max, name);
    if(handle == 0)
      throw new SemaphoreFailedException();
  }
 
  public void Acquire()
  {
    while(true)
    { //looped 0.5s timeout to make NT-blocked threads interruptable.
      uint res = NTKernel.WaitForSingleObject(handle,
       interruptReactionTime);
      try {System.Threading.Thread.Sleep(0);}
      catch(System.Threading.ThreadInterruptedException e)
      {
        if(res == 0)
        { //Rollback
          int previousCount;
          NTKernel.ReleaseSemaphore(handle,1,out previousCount);
        }
        throw e;
      }
      if(res == 0)
        return;
      if(res != 258)
        throw new SemaphoreFailedException();
    }
  }
 
  public void Acquire(TimeSpan timeout)
  {
    uint milliseconds = (uint)timeout.TotalMilliseconds;
    if(NTKernel.WaitForSingleObject(handle, milliseconds) != 0)
      throw new SemaphoreFailedException(); 
  }
 
  public void Release()
  {
    int previousCount;
    if(!NTKernel.ReleaseSemaphore(handle, 1, out previousCount))
      throw new SemaphoreFailedException(); 
  }
 
  #region IDisposable Member
  public void Dispose()
  {
    if(handle != 0)
    {
      if(NTKernel.CloseHandle(handle))
        handle = 0;
    }
  }
  #endregion
}

　　有一点很重要：win32中的信号量是可以命名的。这允许其他进程通过名字来创建相应信号量的句柄。为了让阻塞线程可以中断，我们使用了一个（不好）的替代方法：使用超时和 Sleep(0)。我们需要中断来安全关闭线程。更好的做法是：确定没有线程阻塞之后才释放信号量，这样程序才可以完全释放资源并正确退出。

你可能也注意到了：跨线程和跨进程的信号量都使用了相同的接口。所有相关的类都使用了这种模式，封闭性。需要注意：出于性能考虑，你不应该将跨进程的信号量用到跨线程的场景，也不应该将跨线程的实现用到单线程的场景。