c# - function1 和 function2 是否以线程安全的方式使用我的串口类？

Question

我有一个围绕串行端口的包装器类，看起来像这样:

static class HASPCLass
{
  private static SerialPort m_port;
  private static bool m_initialized;
  private static int m_baudRate;
  static readonly object _syncObject = new object(); 
  public DoInitialization(int baudRate /*also could be other params*/)
  {
    lock(_syncObject)
    {
       if (!m_initialized)
       {
         Initialize(baudRate);
       }
    }
  }

  private Initialize(int baudrate /*also could have other params*/)
  {
     m_port.open(..);
     m_baudRate = baudRate;
     m_initialized = true;
  }

  private Uninitialize()
  {
     m_port.close();
     m_initialized = false;
  }



  public void Read(byte[] buff) 
  {
    lock(_syncObject)
    {
      //Other custom read stuff
      m_port.Read(buff);
    }
  }

  public void Write(byte [] buff) 
  {
    lock(_syncObject)
    {
      //Other write related code
      m_port.Write(buff);
    }
  }

  public void Close() 
  {
    lock(_syncObject)
    {
       if (m_initialized)
       {
         Uninitialize();
       }
    }
  }
}

我试着让这个类线程安全。有人初始化它 - 读取和写入可能被其他线程使用 - 最后调用 Close。

现在假设我有两个额外的静态方法来自其他类，它们执行如下操作:

public static void function1()
{
 HASPClass.Read(...);

 // Some other code

 HASPClass.Write(...);
}

public static void function2()
{
 HASPClass.Read(...);

 // Some other code

 HASPClass.Write(...);
}

为了整体线程安全，我还将这些函数封装在锁中:

public static void function1()
{
   lock(otherlock1)
   {
     HASPClass.Read(...);

     // Some other code

     HASPClass.Write(...); 
    }
}

public static void function2()
{
   lock(otherlock1)
   {
      HASPClass.Read(...);

      // Some other code

      HASPClass.Write(...); 
    }
}

因为读取和写入的调用顺序可能与 HASP 相关。我的问题是:现在我的 final方法(使用 function1 和 function2)是否正确/线程安全？

Answer 1

由于您使用的是单例，因此无需额外的锁就可以，只要函数不使用必须在 //一些其他代码 中锁定的资源即可。该类本身是线程安全的，因为它使用同一个锁锁定变量的所有使用。这太紧了。但请确保不要在注释后面的代码中引入死锁。

一般来说，你应该确保在所有线程都完成它之前没有人关闭你的对象。

此外，此代码示例或多或少不一致。您不会将其声明为静态的，也不会写任何返回类型。

编辑:从需要以特殊顺序发出命令的更高角度来看，我更正了声明并说是的，你需要锁定它。

但是要小心死锁。这是如何出错的更明确的方式(尽管我没有在您的示例代码中看到它发生):

有2个线程可以持有锁。您的设备将始终向您发送 1，除非您向它传输 2，然后它会向您发送 2。

线程 1 尝试首先从设备读取 1，然后再读取 2，但不释放锁。

现在假设在接收到 1 后采取的操作以某种方式启动线程 2，该线程 2 想要将 2 传输到设备。但它不能，因为线程 1 仍在等待，但它将永远等待，因为线程 2 无法传输。最常见的情况是与 invoke 一起使用的 GUI 事件(这会导致另一个线程执行代码)。