Question

我在继承的类中使用过互斥锁，但似乎它不能像我预期的那样使用线程。请看下面的代码：

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

// mutex::lock/unlock
#include <iostream>       // std::cout
#include <thread>         // std::thread
#include <chrono>         // std::thread
#include <mutex>          // std::mutex

typedef unsigned int UINT32t;
typedef int INT32t;

using namespace std;



class Abstract {

protected:
    std::mutex mtx;
};


class Derived: public Abstract
{
public:
    void* write( void* result)
    {
        UINT32t error[1];
        UINT32t data = 34;
        INT32t length = 0;
        static INT32t counter = 0;

        cout << "\t   before Locking ..." << " in thread"  << endl;

        mtx.lock();
        //critical section
        cout << "\t    After Create " << ++ counter  << " device in thread"  << endl;

        std::this_thread::sleep_for(1s);

        mtx.unlock();
        cout << "\t    deallocated " << counter << " device in thread"  << endl;
        pthread_exit(result);
    }
};

void* threadTest1( void* result)
{
    Derived dev;

    dev.write(nullptr);
}


int main()
{
    unsigned char byData[1024] = {0};
    ssize_t len;
    void *status = 0, *status2 = 0;
    int result = 0, result2 = 0;

    pthread_t pth, pth2;
    pthread_create(&pth, NULL, threadTest1, &result);
    pthread_create(&pth2, NULL, threadTest1, &result2);


    //wait for all kids to complete
    pthread_join(pth, &status);
    pthread_join(pth2, &status2);

    if (status != 0) {
           printf("result : %d\n",result);
       } else {
           printf("thread failed\n");
       }


    if (status2 != 0) {
           printf("result2 : %d\n",result2);
       } else {
           printf("thread2 failed\n");
       }


    return -1;
}

所以结果是：

*预期有四到五个论点。

   before Locking ... in thread
    After Create 1 device in thread
   before Locking ... in thread
    After Create 2 device in thread
    deallocated 2 device in thread
    deallocated 2 device in thread
       thread failed
       thread2 failed

*

所以在这里我们可以看到，在释放互斥锁之前，第二个线程进入临界区。字符串＆＃34;在线程中创建2设备＆＃34;对此说。如果在释放互斥锁之前进入临界区，则意味着互斥锁工作错误。

如果您有任何想法，请分享。

感谢

Answer 1

互斥锁本身（可能）工作正常（我建议您使用std::lock_guard但是）但两个线程都会创建自己的Derived对象，因此，他们不会这样做。使用相同的互斥锁。

Answer 2

编辑：tkausl的答案是正确的 - 但是，即使您切换到使用全局互斥锁，输出也可能不会因为我的答案中的详细信息而改变，所以我将它留在这里。换句话说，有两个原因导致输出可能不是您所期望的，并且您需要修复它们。

特别注意这两行：

mtx.unlock();
cout << "\t    deallocated " << counter << " device in thread"  << endl;

您似乎认为这两行将一个接一个地运行，但不能保证这将在抢占式多线程环境中发生。可能发生的事情就是mtx.unlock()之后可能会有一个上下文切换到另一个线程。

换句话说，第二个线程等待互斥锁解锁，但第一个线程不打印＆＃34;解除分配＆＃34;第二个线程抢占之前的消息。

获得预期输出的最简单方法是交换这两行的顺序。

Answer 3

您应将您的互斥锁声明为全局变量并在调用pthread_create之前启动它。您使用pthread_create创建了两个线程，并且它们都创建了自己的互斥锁，因此它们之间绝对没有同步。

Mutex无法按预期工作

3 个答案: