C++如何使用函子使用std :: mutex和std :: lock_guard？

Question

我正在学习如何在标准C++中使用std::thread，并且我无法用std::mutex解决一个问题。

我正在运行2个线程，使用简单的函数在CMD中显示一条消息。我想使用std::mutex，以便一个线程将等待，直到其他威胁停止使用缓冲区。

当我使用功能一切正常，但与仿函数我有一个问题：

错误C2280： '的std ::互斥::互斥（常量的std ::互斥&）'：尝试以引用删除的功能

我在做什么错？

#include <iostream> 
#include <thread> 
#include <mutex> 

class thread_guard 
{ 
    private: 
     std::thread m_thread; 
    public: 
     thread_guard(std::thread t) 
     { 
      m_thread = std::move(t); 
      if (!m_thread.joinable()) 
       std::cout << "Brak watku!!!" << std::endl; 
     } 
     ~thread_guard() 
     { 
      m_thread.join(); 
     } 
}; 

class func 
{ 
    private: 
     std::mutex mut; 
    public: 
     void operator()() 
     {   
      for (int i = 0; i < 11000; i++) 
      { 
       std::lock_guard<std::mutex> guard(mut); 
       std::cout << "watek dziala 1" << std::endl; 
      } 
     } 
}; 

class func2 
{ 
    private: 
     std::mutex mut; 
    public: 
     void operator()() 
     {   
      for (int i = 0; i < 11000; i++) 
      { 
       std::lock_guard<std::mutex> guard(mut); 
       std::cout << "watek dziala 2" << std::endl; 
      } 
     } 
}; 

std::mutex mut2; 

void fun() 
{ 
    for (int i = 0; i < 11000; i++) 
    { 
     std::lock_guard<std::mutex> guard(mut2); 
     std::cout << "watek dziala 1" << std::endl;  
    } 
} 

void fun2() 
{ 
    for (int i = 0; i < 11000; i++) 
    { 
     std::lock_guard<std::mutex> guard(mut2); 
     std::cout << "watek dziala 2" << std::endl; 
    } 
} 

int main(void) 
{ 
    thread_guard t1((std::thread(func()))); 
    thread_guard t2((std::thread(func2()))); 
    //thread_guard t1((std::thread(fun))); 
    //thread_guard t2((std::thread(fun2))); 
} 

Answer 1

你实际上有两个的问题。编译错误是因为函数对象复制了，但嵌入式互斥锁没有有效的复制构造函数，所以出现错误。相反，你必须创建对象的实例，并通过成员函数和一个指向对象：

func f1; 
thread_guard t1(std::thread(&func::operator(), &f1)); 

注意，这并没有真正有用在这种情况下使用的功能。

---

另一个问题是每个仿函数对象都有自己的互斥量，所以两个线程将完全独立运行。

例如，如果您将互斥量设为全局，那么您也可以解决第一个问题，并且可以毫无问题地使用函子。

Answer 2

在你的代码中，每个function都拥有一个互斥量。这些是不同的互斥体，而且他们确实没有任何防范措施。

问题是一个函数需要是可复制的，互斥量不是。如果函数需要锁定一个互斥锁，它通常是一些共享资源，你可以通过引用你的函数来传递这个互斥锁。

在外面创建互斥锁，例如，在main（），然后

class func 
{ 
    std::mutex * mutex; 

public: 
    explicit func(std::mutex & m) : mutex(&m) 
    { 
    } 

    void operator()() 
    { 
     for (int i = 0; i < 11000; i++) 
     { 
      std::lock_guard<std::mutex> guard(*mutex); 
      std::cout << "watek dziala 1" << std::endl; 
     } 
    }  
}; 

类似用于FUNC2

int main(void) 
{ 
    std::mutex mutex; 
    thread_guard t1((std::thread(func(mutex)))); 
    thread_guard t2((std::thread(func2(mutex)))); 

}