Question

我正在学习关键部分（出于多线程的目的），我在网上找到了一个使用它的课程。我不明白为什么我的代码不起作用 - 我应该在控制台显示器上获得“成功”但我没有。

我是否错误地锁定了它？我确信我准确地进入和退出这些部分 - 但我不知道为什么第三个线程（mul）似乎不起作用。

这是主要代码（在VS 2012上执行此操作）：

#include "stdafx.h"
#include <windows.h>
#include <process.h>
#include <iostream>
#include <assert.h>
#include <queue>
#include "Lock.h"

//File: CriticalSectionExample.cpp

#define MAX_THREADS 2

using namespace std;

static unsigned int counter = 100;
static bool alive = true;
static examples::Lock lock_1;
static examples::Lock lock_2;

queue<int> test_q;
queue<int> later_q;

static unsigned __stdcall sub(void *args)
{
    while(alive)
    {
        cout << "tq";
        lock_1.acquire();
        test_q.push(1);
        lock_1.release();

        ::Sleep(500);
    }
    return 0;
}

static unsigned __stdcall add(void *args)
{
    while(alive)
    {
        if (!test_q.empty())
        {
            int first = test_q.front();
            //cout << first << endl;

            lock_1.acquire();
            test_q.pop();
            lock_1.release();

            lock_2.acquire();
            cout << "lq" << first << endl;
            later_q.push(first);
            lock_2.release();
        }

        ::Sleep(500);
    }
    return 0;
}

static unsigned __stdcall mul(void *args)
{
    while(alive)
    {
        if (!later_q.empty())
        {
            cout << "success" << endl;
            lock_2.acquire();
            test_q.pop();
            lock_2.release();
        }

        ::Sleep(500);
    }
    return 0;
}

int main()
{
    // create threads
    unsigned tadd;
    HANDLE hadd = (HANDLE) ::_beginthreadex(0, 0, &add, 0, CREATE_SUSPENDED, &tadd);
    assert(hadd != 0);

    unsigned tsub;
    HANDLE hsub = (HANDLE) ::_beginthreadex(0, 0, &sub, 0, CREATE_SUSPENDED, &tsub);
    assert(hsub != 0);

     unsigned tmul;
    HANDLE hmul = (HANDLE) ::_beginthreadex(0, 0, &mul, 0, CREATE_SUSPENDED, &tsub);
    assert(hmul != 0);

    // start threads
    ::ResumeThread(hadd);
    ::ResumeThread(hsub);

    ::Sleep(10000); // let threads run for 10 seconds

    // stop & cleanup threads
    alive = false;
    ::WaitForSingleObject(hsub, INFINITE);
    ::CloseHandle(hsub);
    ::WaitForSingleObject(hadd, INFINITE);
    ::CloseHandle(hadd);

    return 0;
}

这是包含Critical Section：

的头文件

#ifndef _Lock_H_
#define _Lock_H_


#include <windows.h>

/**
*@description: A simple Lock implementation using windows critical section object
*/

namespace examples
{
    class Lock
    {
    public:
        Lock()
        {
            ::InitializeCriticalSection(&m_cs);
        }

        ~Lock()
        {
            ::DeleteCriticalSection(&m_cs);
        }

        void acquire()
        {
            ::EnterCriticalSection(&m_cs);
        }

        void release()
        {
            ::LeaveCriticalSection(&m_cs);
        }

    private:
        Lock(const Lock&);
        Lock& operator=(const Lock&);

        CRITICAL_SECTION m_cs;
    };

}

#endif //_Lock_H_

Answer 1

您似乎忘了恢复第三个帖子。

我想说你的代码中存在一些潜在的缺陷。我建议您锁定使用共享变量的每个地方（是的，即使您只读取它们的值）。这次它可能有效，但有时甚至读取被其他线程修改的对象也可能是危险的。

此外，您可以在代码中应用更复杂的Free / Lock模式，因此您无需手动调用acquire / release

class AutoLock
{
public:
    AutoLock(Lock& l)
    :lock(l)
    {
        lock.acquire();
    }

    ~AutoLock()
    {
        lock.release();
    }

    Lock& lock;
 };

然后你可以重写你的功能，使它们更清洁，更安全：

static unsigned __stdcall sub(void *args)
{
    while(alive)
    {
        cout << "tq";
        {
            examples::AutoLock lock(lock_1);
            test_q.push(1);
        }
        ::Sleep(500);
    }
    return 0;
}

请注意，需要单独的范围，因为否则关键部分lock_1将被锁定，直到:: Sleep（500）执行，这不是您通常想要的。

嵌套锁（临界区）无法正常工作

1 个答案: