多线程练习
Exercise of multithreading
我有这个多线程练习要解决。我必须创建一个 class,其中 5 个线程相互等待,当第 5 个线程到达时,它们全部解锁。
我想使用互斥量和条件变量,但我不知道我是否用得好。
我使用 add() 方法创建了一个 class ,该方法将 variableX 递增 1,创建了一个线程来接收函数 print() 并稍后将其加入()。函数 print() 检查变量 X 是否小于 5,如果是则条件变量等待,否则条件变量使用 notify_all() 函数唤醒所有线程。编译器给出 0 错误,但通过调试我发现程序陷入死锁。这是一个片段
#include "stdafx.h"
#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
using namespace std;
void print(mutex & mtx, condition_variable & convar, int x) {
if (x < 5){
unique_lock<mutex> lock(mtx); //acquire and lock the mutex
convar.wait(lock); //unlock mutex and wait
}
else {
convar.notify_all();
cout << "asdasd" << endl;
}
}
class foo {
public:
void add() {
this->x = x + 1;
thread t1(print, ref(mtx), ref(cv), x);
t1.join();
}
private:
mutex mtx;
condition_variable cv;
int x;
};
int main() {
foo f;
f.add();
f.add();
f.add();
f.add();
f.add();
}
你的函数
void add() {
this->x = x + 1;
thread t1(print, ref(mtx), ref(cv), x);
t1.join();
}
创建一个线程,然后等待 (join()
) 直到线程结束。因为你的线程函数
void print(mutex & mtx, condition_variable & convar, int x) {
if (x < 5){
unique_lock<mutex> lock(mtx);
convar.wait(lock); // waits if x < 5
}
// ...
和 x
是可以推测的(你没有初始化它)< 5 你有你的僵局。
#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
#include <condition_variable>
using namespace std;
void print(mutex & mtx, condition_variable & convar, int x)
{
if (x < 5) {
unique_lock<mutex> lock{ mtx };
convar.wait(lock);
} else {
convar.notify_all();
cout << "asdasd\n";
}
}
class foo {
private:
mutex mtx;
condition_variable cv;
int x{ 0 };
std::vector<thread> threads;
public:
void add() {
++x;
threads.push_back(thread(print, ref(mtx), ref(cv), x));
}
~foo() {
for (auto &t : threads)
t.join();
}
};
int main() {
foo f;
f.add();
f.add();
f.add();
f.add();
f.add();
}
我有这个多线程练习要解决。我必须创建一个 class,其中 5 个线程相互等待,当第 5 个线程到达时,它们全部解锁。 我想使用互斥量和条件变量,但我不知道我是否用得好。 我使用 add() 方法创建了一个 class ,该方法将 variableX 递增 1,创建了一个线程来接收函数 print() 并稍后将其加入()。函数 print() 检查变量 X 是否小于 5,如果是则条件变量等待,否则条件变量使用 notify_all() 函数唤醒所有线程。编译器给出 0 错误,但通过调试我发现程序陷入死锁。这是一个片段
#include "stdafx.h"
#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
using namespace std;
void print(mutex & mtx, condition_variable & convar, int x) {
if (x < 5){
unique_lock<mutex> lock(mtx); //acquire and lock the mutex
convar.wait(lock); //unlock mutex and wait
}
else {
convar.notify_all();
cout << "asdasd" << endl;
}
}
class foo {
public:
void add() {
this->x = x + 1;
thread t1(print, ref(mtx), ref(cv), x);
t1.join();
}
private:
mutex mtx;
condition_variable cv;
int x;
};
int main() {
foo f;
f.add();
f.add();
f.add();
f.add();
f.add();
}
你的函数
void add() { this->x = x + 1; thread t1(print, ref(mtx), ref(cv), x); t1.join(); }
创建一个线程,然后等待 (join()
) 直到线程结束。因为你的线程函数
void print(mutex & mtx, condition_variable & convar, int x) { if (x < 5){ unique_lock<mutex> lock(mtx); convar.wait(lock); // waits if x < 5 } // ...
和 x
是可以推测的(你没有初始化它)< 5 你有你的僵局。
#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
#include <condition_variable>
using namespace std;
void print(mutex & mtx, condition_variable & convar, int x)
{
if (x < 5) {
unique_lock<mutex> lock{ mtx };
convar.wait(lock);
} else {
convar.notify_all();
cout << "asdasd\n";
}
}
class foo {
private:
mutex mtx;
condition_variable cv;
int x{ 0 };
std::vector<thread> threads;
public:
void add() {
++x;
threads.push_back(thread(print, ref(mtx), ref(cv), x));
}
~foo() {
for (auto &t : threads)
t.join();
}
};
int main() {
foo f;
f.add();
f.add();
f.add();
f.add();
f.add();
}