具有线程安全std :: cout的死锁

debugcn 发表于 Dev

史蒂夫·默多克

我正在尝试使用EnterCriticalSection和LeaveCriticalSection的Windows API来实现std :: cout的简单，线程安全的变通方法。我认为示例代码是不言自明的，因此我们开始：

#include <cstdlib>
#include <iostream>
#include <windows.h>

namespace mynamespace {

class MyStream {
    public:
        MyStream(void) : m_lockOwner(0) {
            ::InitializeCriticalSection(&m_lock);
        }

        ~MyStream(void) {
            ::DeleteCriticalSection(&m_lock);
        }


        template <typename T>
        MyStream& operator<<(const T& x) {
            Lock();
            std::cout << x;

            return *this;
        }

        void Lock() {
            ::EnterCriticalSection(&m_lock);  // Try to get the lock, irrelevant which thread it is
            // One thread successfully received the lock and entered the critical section
            if(m_lockOwner == ::GetCurrentThreadId()) {
                // Decrease the lock count of a thread when it entered multiple times the critical section
                // e.g. mynamespace::stream << "critsec1" << "critsec2"; mynamespace::stream << mynamespace::endl;
                ::LeaveCriticalSection(&m_lock);
            }
            // Store the thread ID of the thread that holds the lock at the moment
            m_lockOwner = ::GetCurrentThreadId();
        }

        void Unlock() {
           if(m_lockOwner == GetCurrentThreadId()) {
               // Release the lock only if the calling thread is the owner
               // Note: This should be the last decrease of the lock count

               // Also reset the ownership of the lock,
               // e.g. for the case that one thread is able to enter the critical section two times in a row
               // mynamespace::stream << "crit first" << mynamespace::endl;
               // mynamespace::stream << "crit second" << mynamespace::endl;
               m_lockOwner = 0;
               ::LeaveCriticalSection(&m_lock);
           }
        }

        MyStream& operator<<(MyStream& (*endl)(MyStream&)) {
            return endl(*this);
        }

        DWORD            m_lockOwner;
        CRITICAL_SECTION m_lock;
    };

    static MyStream& endl(MyStream& stream) {
        std::cout << std::endl;
        stream.Unlock();
        return stream;
    }

    MyStream stream;

};

bool alive = true;

DWORD my_thread(LPVOID t) {
    while(alive) {
        mynamespace::stream << "OWN THREAD" << mynamespace::endl;
    }

    return 0;
}

void waitForThread(HANDLE th) {
    alive = false;

    // Wait for thread to finish
    (void)::WaitForSingleObject(th, INFINITE);

    ::CloseHandle(th);

    th = 0;
}

int main(void) {
    HANDLE th = ::CreateThread(
        NULL,
        0,
        reinterpret_cast<LPTHREAD_START_ROUTINE>(&my_thread),
        NULL,
        0,
        NULL);

    mynamespace::stream << "test print 1" << "test print 2";
    mynamespace::stream << mynamespace::endl;
    mynamespace::stream << "test print 3";
    ::Sleep(10);
    mynamespace::stream << mynamespace::endl;
    ::Sleep(10);

    waitForThread(th);

    return EXIT_SUCCESS;
}

在我的第一篇文章中，我提到退出程序有时会遇到死锁。

这里的问题是，LeaveCriticalSection当我通过一个线程进入关键部分时，我没有那么频繁地打电话。另一个问题是我没有正确退出子线程。

有了egurs的帮助和我的一些小补充，此流现在应该是线程安全的。

招呼

木头

您多次输入关键部分，从而增加了其参考计数，但是在调用endl时将其释放一次，因此关键部分仍处于锁定状态。

将线程ID存储在您的类中以知道该线程拥有锁。输入关键部分并比较线程ID。相等->这不是第一个锁，因此您需要调用LeaveCriticalSection否则更新线程ID变量。

class MyStream {
...
     void Lock() {
         WaitForCriticalSection(&m_lock);
     }
     DWORD  m_EventOwner;
};

编辑

从原始答案更改了我的解决方案的机制。

这是工作代码：

namespace mynamespace {

class MyStream {
    public:
        MyStream(void) {
            InitializeCriticalSection(&m_lock);
        }

        ~MyStream(void) {
            DeleteCriticalSection(&m_lock);
        }


        template <typename T>
        MyStream& operator<<(const T& x) {
            Lock();
            std::cout << x;

            return *this;
        }

        void Lock() {
            EnterCriticalSection(&m_lock);
            if (m_eventOwner == GetCurrentThreadId()) {
                LeaveCriticalSection(&m_lock);
            }
        }

        void Unlock() {
            if (m_eventOwner != GetCurrentThreadId()) {
                //error!
            }
            LeaveCriticalSection(&m_lock);
        }

        MyStream& operator<<(MyStream& (*endl)(MyStream&)) {
            return endl(*this);
        }

        DWORD  m_eventOwner;
        CRITICAL_SECTION m_lock;
    };

    static MyStream& endl(MyStream& stream) {
        std::cout << std::endl;
        stream.Unlock();
        return stream;
    }

    MyStream stream;

};

本文收集自互联网，转载请注明来源。

如有侵权，请联系[email protected] 删除。