我有第二个问题，该问题是该线程的延续：How Does Windows Pick memory for threads?
void ThreadTest(LPTSTR* Pointer, mutex* MutexPtr)
{
MutexPtr->lock();
wcout << *Pointer << endl;
MutexPtr->unlock();
return;
}
void FakeMain()
{
mutex Mut;
mutex* MutPtr = &Mut;
LPTSTR Image = L"First String";
LPTSTR* StrPointer = &Image;
thread Test(ThreadTest, StrPointer, MutPtr);
MutPtr->lock();
if (true)
{
NewStringFunction(Image);
MutPtr-unlock() // Added with the comment of Mike
Test.join();
LPTSTR* StrPointer = &Image;
thread Test(ThreadTest, StrPointer, MutPtr);
}
MutPtr->lock();
Test.join();
MutPtr->unlock();
return;
};
void NewStringFunction(LPTSTR& Image)
{
LPTSTR TempString = L"New String for new Thread";
Image = TempString;
return;
};
上面的代码是模拟我遇到问题的代码。
流程应如下：
FakeMain（）初始化变量并设置一个String；
然后FakeMain为要打印的字符串创建一个线程。
新线程将打印字符串。
打印线程被破坏，并且一个单独的外部函数创建了一个新字符串。
创建了一个新线程来打印此新消息
我有一个“ if”语句，因为实际的代码在if语句中有一个线程，我想确保内存分配代表了这一点。
在单独的函数中更改字符串，因为这是实际代码执行此操作的方式。
我销毁了第一个线程，因为在实际代码中，该线程正在显示一个窗口，该窗口会更改大小，因此需要一个新线程。
通过编写这段代码，我感到我的互斥体没有正确实现。这段代码没有给出字符串错误，但是我认为互斥锁正在被线程覆盖（我认为）。看着程序运行时的内存，我不确定第一个线程实例可能会覆盖互斥量。主线程中的最后一个Mutex.lock（）引发错误。我是否正确使用互斥锁？有没有一种更干净的方法来锁定/停止线程？
最佳答案
不要使用互斥，也不要共享内存。
蛮力方法：
发件人所需要做的就是
Message msg = new Message(<important information>);
// send msg
在接收代码中
// use msg
delete msg;
编写和使用非常简单，但是会发生内存泄漏：如果消息永远不会得到服务，则它永远不会退还RAM。
更好的版本会变得非常复杂。这是一个简单的概述：
Create a pool of Messages
Assign all messages to a FreeList
Create a mutex to protect FreeList
FreeList是当前未使用的消息列表。当需要发送消息时，第一条消息将从FreeList中删除并传递给调用者。呼叫者用要发送的信息填写消息，然后发送消息。
接收者负责将消息返回给FreeList。
添加一些功能来管理FreeList
GetMsg <changed to prevent collision with Windows GetMessage function>
Message = NULL
acquire mutex
if FreeList not empty
remove Message from FreeList
release mutex
return message
ReturnMsg
acquire mutex
Add Message to FreeList
release mutex
发件人有点复杂
Message msg = GetMessage()
If msg not NULL
msg.set(<important information>);
std::thread temp(ThreadTest, msg);
temp.detatch
else
// log and handle <- can be simple like abort or complicated like recover lost Messages
接收器仍然很简单
// use msg
ReturnMessage(msg);
这样可以限制内存泄漏，并且可以轻松地跟踪从未返回过的消息（在池中，但不在FreeList中），因此您可以尝试跟踪哪些作业被阻塞或炸毁。修复锁定或爆炸是另一个问题。
OP认为我有正确的主意。这是基本线程功能的胆量。它在后台运行，直到发送终止消息为止。它阻止等待消息，使用消息，然后将其放回FreeList中，并阻塞直到另一条消息到达为止。
void threadfunc()
{
MSG winmsg;
BOOL rval;
while (GetMessage(&winmsg, (HWND__ *) -1, 0, 0) != -1)
{
Message * msg = (Message *)winmsg.wParam;
// do stuff with msg
ReturnMsg(msg);
}
// GetMessage failed. Find out why and try to recover or die gracefully
}
它需要像这样的东西来支持
bool PostMsg(<Important Information>,
DWORD & BackgroundThreadId)
{
Message * msg = GetMsg();
if (msg != NULL)
{
msg.set(<Important Information>)
if (PostThreadMessage(BackgroundThreadId,
WM_USER,
(WPARAM) msg,
0); != 0)
{
return true;
}
else
{
// failed. Find out why and try to recover or die gracefully
ReturnMsg(msg);
return false;
}
}
else
{
// out of free messages. Try to find out why
}
}
PostMsg将消息送入后台线程的消息队列。消息来自FreeList，只有FreeList需要互斥保护。可以使用多个线程。我不认为可以使用std :: thread来完成此操作，因为std :: thread不能访问底层线程句柄（只需检查即可）或线程的消息队列。一切都是基于Windows调用的，因此无需考虑可移植性。