如何避免线程化 +优化器==无限循环？

发布于 2024-10-09 10:57:43 字数 883 浏览 0 评论 0原文

在今天的代码审查中，我偶然发现了以下内容代码（为发布而稍加修改）：

while (!initialized)
{
  // The thread can start before the constructor has finished initializing the object.
  // Can lead to strange behavior. 
  continue;
}

这是在新线程中运行的前几行代码。在另一个线程中，一旦初始化完成，它就会将 initialized 设置为 true。

我知道优化器可以将其变成无限循环，但是避免这种情况的最佳方法是什么？

易失性 - 被认为是有害的
调用isInitialized() 函数而不是直接使用变量 - 这会保证内存屏障吗？如果函数被声明为内联怎么办？

还有其他选择吗？

编辑：

应该早点提到这一点，但这是需要在 Windows、Linux、Solaris 等上运行的可移植代码。我们主要使用 Boost.Thread 用于我们的便携式线程库。

原文

In a code review today, I stumbled across the following bit of code (slightly modified for posting):

while (!initialized)
{
  // The thread can start before the constructor has finished initializing the object.
  // Can lead to strange behavior. 
  continue;
}

This is the first few lines of code that runs in a new thread. In another thread, once initialization is complete, it sets initialized to true.

I know that the optimizer could turn this into an infinite loop, but what's the best way to avoid that?

volatile - considered harmful
calling an isInitialized() function instead of using the variable directly - would this guarantee a memory barrier? What if the function was declared inline?

Are there other options?

Edit:

Should have mentioned this sooner, but this is portable code that needs to run on Windows, Linux, Solaris, etc. We use mostly use Boost.Thread for our portable threading library.

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

贱贱哒 2024-10-16 10:57:43

调用函数根本没有帮助；即使函数未声明为内联，其主体仍然可以内联（除非出现极端情况，例如将您的 isInitialized() 函数放入另一个库中并动态链接到它）。

我想到了两个选项：

将 initialized 声明为原子标志（在 C++0x 中，您可以使用 std::atomic_flag；否则，您将想要查阅线程库的文档以了解如何执行此操作）
使用信号量；在另一个线程中获取它并在本线程中等待它。

回复收藏 0 原文

始于初秋 2024-10-16 10:57:43

@Karl 的评论就是答案。在线程 B 完成初始化之前，不要在线程 A 中开始处理。这样做的关键是从线程 B 向线程 A 发送一个信号，表明它已启动并正在运行。跑步。

你提到没有操作系统，所以我会给你一些 Windows 风格的伪代码。转码到您选择的操作系统/库。

首先创建一个 Windows 事件对象。这将用作信号：

线程 A：

HANDLE running = CreateEvent(0, TRUE, FALSE, 0);

然后让线程 A 启动线程 B，并将事件传递给它：

线程 A：

DWORD thread_b_id = 0;
HANDLE thread_b = CreateThread(0, 0, ThreadBMain, (void*)handle, 0, &thread_b_id);

现在在线程 A 中，等待事件发出信号：

线程 A：

DWORD rc = WaitForSingleObject(running, INFINITE);
if( rc == WAIT_OBJECT_0 )
{
  // thread B is up & running now...
  // MAGIC HAPPENS
}

线程 B 的启动例程执行其任务初始化，然后发出事件信号：

线程 B：

DWORD WINAPI ThreadBMain(void* param)
{
  HANDLE running = (HANDLE)param;
  do_expensive_initialization();
  SetEvent(running); // this will tell Thread A that we're good to go
}

@Karl's comment is the answer. Don't start processing in thread A until thread B has finished initialization. They key to doing this is sending a signal from thread B to thread A that it is up & running.

You mentioned no OS, so I will give you some Windows-ish psudocode. Transcode to the OS/library of your choice.

First create a Windows Event object. This will be used as the signal:

Thread A:

HANDLE running = CreateEvent(0, TRUE, FALSE, 0);

Then have Thread A start Thread B, passing the event along to it:

Thread A:

DWORD thread_b_id = 0;
HANDLE thread_b = CreateThread(0, 0, ThreadBMain, (void*)handle, 0, &thread_b_id);

Now in Thread A, wait until the event is signaled:

Thread A:

DWORD rc = WaitForSingleObject(running, INFINITE);
if( rc == WAIT_OBJECT_0 )
{
  // thread B is up & running now...
  // MAGIC HAPPENS
}

Thread B's startup routine does its initialization, and then signals the event:

Thread B:

DWORD WINAPI ThreadBMain(void* param)
{
  HANDLE running = (HANDLE)param;
  do_expensive_initialization();
  SetEvent(running); // this will tell Thread A that we're good to go
}

回复收藏 0 原文