Multithreading C++/Cli正在同步写入文件的线程

我试图通过使用Monitor将数据写入类中的文本文件来同步线程，但在我的代码中，似乎从来没有计算else语句，这是Monitor用于线程同步的正确用法吗

void Bank::updatefile()
{
Thread^ current = Thread::CurrentThread; 
bool open = false;
current->Sleep(1000);
while (!open)
{
    if (Monitor::TryEnter(current))
    {
        String^ fileName = "accountdata.txt";
        StreamWriter^ sw = gcnew StreamWriter(fileName);
        for (int x = 0; x < 19; x++)
            sw->WriteLine(accountData[x]);
        sw->Close();

        Monitor::Pulse;
        Monitor::Exit(current);
        current->Sleep(500);
        open = true;
    }
    else
    {
        Monitor::Wait(current);
        current->Sleep(500);
    }
}

void Bank:：updatefile（）
{
线程^current=线程：：当前线程；
bool open=false；
当前->睡眠（1000）；
当（！打开）
{
if（监视器：：TryEnter（当前））
{
字符串^fileName=“accountdata.txt”；
StreamWriter ^sw=gcnew StreamWriter（文件名）；
对于（int x=0；x<19；x++）
sw->WriteLine（accountData[x]）；
sw->Close（）；
监视器：脉冲；
监视器：：退出（当前）；
当前->睡眠（500）；
开放=真实；
}
其他的
{
监视器：：等待（当前）；
当前->睡眠（500）；
}
}

---

}

您正在将一个对象传递给执行该对象的线程所特有的

Monitor:：TryEnter

（即

thread^current=thread:：CurrentThread；

）。没有其他线程使用相同的对象（它们将该对象用于自己的线程）。因此，永远不会发生碰撞或锁定冲突

---

尝试创建一些在线程之间共享的通用对象，在

Bank

类中更高级别的对象。然后将其用于您的

TryEnter

呼叫。

您对

监视器的使用部分是正确的。用于锁定的对象不正确

监视器
Monitor:：Pulse
在这里是不必要的。只要退出监视器，下一个线程就可以抓住锁

Monitor:：Wait
在此处不正确：
Wait
应该在线程已锁定对象时使用。在这里，对象尚未锁定

一般来说，
Pulse
和
Wait
很少使用。要锁定对共享资源的独占访问，
Enter
、
TryEnter
和
Exit
都是您所需要的

以下是您如何使用
监视器
：

Object^ lockObj = ...;
bool done = false;
while(!done)
{
    if(Monitor::TryEnter(lockObj, 500)) // wait 500 millis for the lock.
    {
        try
        {
            // do work
            done = true;
        }
        finally
        {
            Monitor::Exit(lockObj);
        }
    }
    else
    {
        // Check some other exit condition?
    }
}

或者，如果
else
为空，可以将其简化为：

Object^ lockObj = ...;
Monitor::Enter(lockObj); // Wait forever for the lock.
try
{
    // do work
}
finally
{
    Monitor::Exit(lockObj);
}

微软提供的一个类使这一切变得更容易：
msclr:：lock
。这个类在没有
^
的情况下使用，它使用析构函数释放锁，而不使用try-finally块

#include <msclr\lock.h>

bool done = false;
while(!done)
{
    msclr::lock lock(lockObj, lock_later);
    if (lock.try_acquire(500)) // wait 500 millis for the lock to be available.
    {
        // Do work
        done = true;
    }
} // <-- Monitor::Exit is called by lock class when it goes out of scope.

{
    msclr::lock lock(lockObj); // wait forever for the lock to be available.
    // Do work
} // <-- Monitor::Exit is called by lock class when it goes out of scope.

#包括
bool done=false；
而（！完成）
{
msclr:：lock lock（lockObj，lock_稍后）；
if（lock.try_acquire（500））//等待500毫秒以使锁可用。
{
//工作
完成=正确；
}
} //