#include <thread>
#include <iostream>
#include <mutex>
#include <vector>
#include <cstdarg>
using namespace std;
template<typename T>
class container
{
public:
void add(T element)//有添加单个元素的add()方法
{
_lock.lock();
_elements.push_back(element);
_lock.unlock();
}
void addrange(int num,...)//添加一批元素的addrange()方法,addrange()方法内只是简单的调用了add()方法。
{
va_list arguments;
va_start(arguments, num);
for (int i = 0; i < num;i++)
{
_lock.lock();
add(va_arg(arguments, T));//这个程序执行起来会进入死锁状态。其原因在于,该容器多次尝试获取同一个互斥量而之前却并没有释放该互斥量,这么做是行不通的
_lock.unlock();
}
va_end(arguments);
}
void dump()
{
_lock.lock();
for (auto e:_elements)
{
cout << e << endl;
}
_lock.unlock();
}
protected:
private:
mutex _lock;
vector<T> _elements;
};
void func(container<int>& cont)
{
cont.addrange(3, rand(), rand(), rand());
}
int main()
{
srand((unsigned int)time(0));
container<int> cont;
thread t1(func, ref(cont));
thread t2(func, ref(cont));
thread t3(func, ref(cont));
t1.join();
t2.join();
t3.join();
cont.dump();
system("pause");
return 0;
}
#include <thread>
#include <iostream>
#include <mutex>
#include <vector>
#include <cstdarg>
using namespace std;
template<typename T>
class container
{
public:
void add(T element)//有添加单个元素的add()方法
{
_lock.lock();
_elements.push_back(element);
_lock.unlock();
}
void addrange(int num,...)//添加一批元素的addrange()方法,addrange()方法内只是简单的调用了add()方法。
{
va_list arguments;
va_start(arguments, num);
for (int i = 0; i < num;i++)
{
_lock.lock();
add(va_arg(arguments, T));//这个程序执行起来会进入死锁状态。其原因在于,该容器多次尝试获取同一个互斥量而之前却并没有释放该互斥量,这么做是行不通的
_lock.unlock();
}
va_end(arguments);
}
void dump()
{
_lock.lock();
for (auto e:_elements)
{
cout << e << endl;
}
_lock.unlock();
}
protected:
private:
recursive_mutex _lock;//这个程序执行起来会进入死锁状态。其原因在于,该容器多次尝试获取同一个互斥量而之前却并没有释放该互斥量,这么做是行不通的。这正是std::recursive_mutex的用武之地,它允许同一个线程多次获得同一个互斥量,可重复获得的最大次数并未具体说明,但一旦查过一定次数,再对lock进行调用就会抛出std::system错误。
vector<T> _elements;
};
void func(container<int>& cont)
{
cont.addrange(3, rand(), rand(), rand());
}
int main()
{
srand((unsigned int)time(0));//明眼的读者可能已经发现了,每次调用func()所产生的数字序列都完全相同。这是因为对srad的初始化是要分线程进行的,对srand()的调用只是在主线程中进行了初始化。在其它的工作线程中,srand并没有得到初始化,所以每次产生的数字序列就是完全相同的了。
container<int> cont;
thread t1(func, ref(cont));
thread t2(func, ref(cont));
thread t3(func, ref(cont));
t1.join();
t2.join();
t3.join();
cont.dump();
system("pause");
return 0;
}
#include <iostream>
#include <mutex>
#include <vector>
#include <cstdarg>
using namespace std;
template<typename T>
class container
{
public:
void add(T element)//有添加单个元素的add()方法
{
_lock.lock();
_elements.push_back(element);
_lock.unlock();
}
void addrange(int num,...)//添加一批元素的addrange()方法,addrange()方法内只是简单的调用了add()方法。
{
va_list arguments;
va_start(arguments, num);
for (int i = 0; i < num;i++)
{
_lock.lock();
add(va_arg(arguments, T));//这个程序执行起来会进入死锁状态。其原因在于,该容器多次尝试获取同一个互斥量而之前却并没有释放该互斥量,这么做是行不通的
_lock.unlock();
}
va_end(arguments);
}
void dump()
{
_lock.lock();
for (auto e:_elements)
{
cout << e << endl;
}
_lock.unlock();
}
protected:
private:
mutex _lock;
vector<T> _elements;
};
void func(container<int>& cont)
{
cont.addrange(3, rand(), rand(), rand());
}
int main()
{
srand((unsigned int)time(0));
container<int> cont;
thread t1(func, ref(cont));
thread t2(func, ref(cont));
thread t3(func, ref(cont));
t1.join();
t2.join();
t3.join();
cont.dump();
system("pause");
return 0;
}
#include <thread>
#include <iostream>
#include <mutex>
#include <vector>
#include <cstdarg>
using namespace std;
template<typename T>
class container
{
public:
void add(T element)//有添加单个元素的add()方法
{
_lock.lock();
_elements.push_back(element);
_lock.unlock();
}
void addrange(int num,...)//添加一批元素的addrange()方法,addrange()方法内只是简单的调用了add()方法。
{
va_list arguments;
va_start(arguments, num);
for (int i = 0; i < num;i++)
{
_lock.lock();
add(va_arg(arguments, T));//这个程序执行起来会进入死锁状态。其原因在于,该容器多次尝试获取同一个互斥量而之前却并没有释放该互斥量,这么做是行不通的
_lock.unlock();
}
va_end(arguments);
}
void dump()
{
_lock.lock();
for (auto e:_elements)
{
cout << e << endl;
}
_lock.unlock();
}
protected:
private:
recursive_mutex _lock;//这个程序执行起来会进入死锁状态。其原因在于,该容器多次尝试获取同一个互斥量而之前却并没有释放该互斥量,这么做是行不通的。这正是std::recursive_mutex的用武之地,它允许同一个线程多次获得同一个互斥量,可重复获得的最大次数并未具体说明,但一旦查过一定次数,再对lock进行调用就会抛出std::system错误。
vector<T> _elements;
};
void func(container<int>& cont)
{
cont.addrange(3, rand(), rand(), rand());
}
int main()
{
srand((unsigned int)time(0));//明眼的读者可能已经发现了,每次调用func()所产生的数字序列都完全相同。这是因为对srad的初始化是要分线程进行的,对srand()的调用只是在主线程中进行了初始化。在其它的工作线程中,srand并没有得到初始化,所以每次产生的数字序列就是完全相同的了。
container<int> cont;
thread t1(func, ref(cont));
thread t2(func, ref(cont));
thread t3(func, ref(cont));
t1.join();
t2.join();
t3.join();
cont.dump();
system("pause");
return 0;
}