线程静态类方法与全局范围

Question

想象一下应用程序的功能，需要最多 5 个线程处理数据，这些线程使用缓冲区、互斥体和事件来相互交互。性能至关重要，语言是C++。

该功能可以作为具有一个类的一个（编译）单元来实现，并且只能为应用程序实例化该类的一个实例。该类本身在 run() 方法中实现了 1 个线程，该方法生成其他 4 个线程，管理它们并在用户关闭应用程序时收集它们。

选择以下方法之一相对于另一种方法有什么优势（请让我知道任何更好的方法）？

1. 向类添加 5 个静态方法，每个方法运行一个线程，互斥体和其他数据作为静态类变量共享。
2. 添加 5 个全局函数（无作用域）并使用全局变量、事件和互斥体（就好像它是 C）
3. 完全改变模式，添加 4 个类，每个类实现一个线程并通过全局变量共享数据。

这里有一些需要考虑的想法和问题（如果错误请纠正）：

1. 将线程作为类成员（当然是静态的），它们可以依赖单例来访问非静态成员函数，它也给了它们一个命名空间这本身似乎是个好主意。
2. 使用静态类方法，类头文件很快将包含许多静态变量（以及其他辅助静态方法）。必须在类头文件中声明变量可能会给包含该头文件的其他单元带来额外的依赖性。如果全局声明变量，则它们可以隐藏在单独的头文件中。
3. 静态类变量应该在代码中的某个位置定义，因此它使类型声明的内容加倍。
4. 编译器可以利用命名空间解析来获得更优化的代码（而不是可能位于不同单元中的全局变量）。
5. 单个单元有可能得到更好的优化，而整个程序的优化速度很慢，而且可能效果较差。
6. 如果单元增长，我必须将代码的某些部分移动到单独的单元，所以我将拥有一个具有多个（编译）单元的类，这是否是反模式？
7. 如果使用多个类，每个类处理一个线程，那么可以再次提出同样的问题来决定静态方法和全局函数之间来实现线程。此外，这需要更多的代码留置权，这不是一个真正的问题，但值得额外的开销吗？

请假设没有 Qt 等库，然后假设我们可以依赖 QThread 并为每个 run() 方法实现一个线程，然后回答这个问题。

Edit1：每个设计的线程数是固定的，数字 5 只是一个例子。请分享您对方法/模式而不是细节的想法。

Edit2：我发现这个答案（针对另一个问题）非常有帮助，我想第一种方法滥用类作为名称空间。如果与命名空间结合使用，可以减轻第二种方法的影响。

Answer 1

首先

，您应该阅读 Herb Sutter 的完整并发文章：

http://herbsutter.com/2010/09/24/ effective-concurrency-know-when-to-use-an-active-object-instead-of-a-mutex/

这是链接到上一篇文章的帖子，其中包含所有以前文章的链接。

你的情况是什么？

根据以下文章：您拥有或需要多少可扩展性？ (http:// /drdobbs.com/parallel/201202924 ），您处于 O(K): Fixed 情况。也就是说，您有一组固定的任务要同时执行。

根据你的应用程序的描述，你有 5 个线程，每个线程都做一件非常不同的事情，所以你必须有 5 个线程，也许希望其中一个或一些线程仍然可以将它们的任务划分为多个线程（因此，使用一个线程池），但这将是一个额外的好处。

我让您阅读这篇文章以获取更多信息。

设计问题

关于单例

忘记单例吧。这是一个愚蠢且过度使用的模式。

如果您真的想限制类的实例数量（说真的，您没有比这更好的事情了吗？），您应该将设计分为两部分：一个用于数据的类，一个用于包装的类前面的类进入了单例限制。

关于编译单元

让您的标题和源代码易于阅读。如果您需要将一个类的实现放到多个源中，那就这样吧。我相应地命名了来源。例如，对于类 MyClass，我将具有：

• MyClass.hpp ：标头
• MyClass.cpp ：主要源代码（带有构造函数等）
• MyClass.Something.cpp ：带有某些内容的源处理
• MyClass.SomethingElse.cpp ：源处理关于
• 。

编译器优化

最近的编译器能够内联来自不同编译单元的代码（我在 Visual C++ 2008，IIRC 上看到了该选项） 我不知道整个全局优化是否比“一个单元”编译更糟糕，但即使是这样，您仍然可以将代码划分为多个源，然后让一个全局源包含所有内容。例如：

• MyClassA.header.hpp
• MyClassB.header.hpp
• MyClassA.source.hpp
• MyClassB.source.hpp
• global.cpp

，然后相应地进行包含。但您应该确保这实际上可以提高您的性能：除非您确实需要它并且您对其进行了分析，否则不要进行优化。

你的情况，但更好？

您的问题和评论更多地涉及整体设计，而不是性能或线程问题，所以我可能是错的，但您需要的是简单的重构。

我会使用第三种方法（每个线程一个类），因为类具有私有/公共访问权限，因此，您可以使用它来保护一个线程拥有的数据，只需将其设置为私有。

以下指南可以帮助您：

1 - 每个线程都应该隐藏在一个非静态对象中

您可以使用该类的私有静态方法，也可以使用匿名命名空间函数（我会选择对于函数，但在这里，我想访问类的私有函数，所以我将选择静态方法）。

通常，线程构造函数允许您将指针传递给带有 void * 上下文参数的函数，因此使用它将 this 指针传递给主线程函数

：每个线程的类可以帮助您隔离该线程，从而将该线程的数据与外部世界隔离：没有其他线程能够访问该数据，因为它是私有的。

这是一些代码

// Some fictious thread API
typedef void (*MainThreadFunction)(void * p_context) ;
ThreadHandle CreateSomeThread(MainThreadFunction p_function, void * p_context) ;

// class header
class MyClass
{
   public :
      MyClass() ;
      // etc.

      void         run() ;

   private :
      ThreadHandle m_handle ;

      static void  threadMainStatic(void * p_context) ;
      void         threadMain() ;
}

：

// source
void MyClass::run()
{
   this->m_handle = CreateSomeThread(&MyClass::threadMainStatic, this) ;
}

void MyClass::threadMainStatic(void * p_context)
{
   static_cast<MyClass *>(p_context)->threadMain() ;
}

void MyClass::threadMain()
{
   // Do the work
}

Displaimer：这没有在编译器中进行测试。与其将其视为伪 C++ 代码，不如将其视为实际代码。 YMMV。

2 - 标识不共享的数据。

这些数据可以隐藏在所属对象的私有部分中，如果它们受到同步保护，那么这种保护就太过分了（因为数据不共享）

3 - 识别共享的数据

...并验证其同步性（锁、原子访问）

4 - 每个类应该有自己的标头和源

...并保护对其（共享）的访问数据同步，如有必要

5 - 尽可能保护访问

如果一个函数由一个类使用，并且仅一个类使用，并且并不真正需要访问类内部，那么它可以隐藏在匿名名称空间中。

如果一个变量仅由一个线程拥有，则将其作为私有变量成员隐藏在类中。

ETC。