Fork me on GitHub

C11++并发与多线程

字数统计: 5.3k字   |   阅读时长≈ 25分

并发：表示两个或者多个任务同时发生。

并行：只得就是在同一时刻，有两个或多个任务（进程），代码在处理器上执行，必须是多核CPU

并发并不是并行，并发关乎结构，并行关乎执行

C++基于多线程模型的应用设计就是一种典型的并发程序设计

Thread实现线程

main相当于主线程，如果保持子线程一直处于执行状态，必须让主线程保持执行，千万不要主线程执行完毕。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include<iostream>
#include<thread>
using namespace std;

// 创建可调用对象
void myprint()
{
	cout << "我的子线程执行完了" << endl;
}
int main()
{
	// thread 是c++ 标准库里的一个类就是创建线程的
	std::thread myobj(myprint);
	myobj.join(); // 阻塞，主线程等待子线程执行完毕 如果注释掉则报异常
    // 用detach 替换join()
    // myobj.detach();
	cout << "main thread is running" << endl;
	return 0;

}

一个书写良好的程序： 主线程等待子线程执行完毕，自己才能最终退出

detach

detach是一种让子线程和主线程分离的方法，主线程执行主线程的，子线程执行子线程的，新创建的子线程被C++ 运行时库接管了，当这个线程执行完毕后，运行时库负责清理该线程的相关资源，相当于linux里面的守护线程

对于同一个线程一但用detach，就不能用join，否则导致程序异常

joinable

joinable判断是否可以用join或detach

1
2
3
4
5
6
7
8
9
10
std::thread myobj(myprint);

if (myobj.joinable())
{
	cout << "execue" << endl;
	myobj.join();
}
else {
	cout << "no execue" << endl;
}

用类来创建线程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Ta {
public:
	// 运算符重载，相当一个伪函数,可调用对象
	void operator()()
	{
		cout << "operator 开始执行了" << endl;
	}
};
int main()
{
	Ta ta;
	std::thread myobj(ta);
	myobj.join();
	
	cout << "main thread is running" << endl;
	return 0;

}

ta对象是一个复制，用myobj.detach 没有影响，但是如果对象里面有引用或指针就会产生问题，如构造函数

Ta(int& i)

主线detach后会销毁 变量

lamda表达式来创建线程

1
2
3
4
5
6
7
8
9
10
11
12
13
auto mylamda = []
	{
		cout << "my lamda is running " << endl;
	};

int main()
{

	std::thread myobj(mylamda);
	myobj.join();
	cout << "main thread is running" << endl;
	return 0;
}

所以如果真要用detach这种方式创建线程，记住不要往线程中传递引用、指针之类的参数

如果用detach创建线程，会有些陷阱

  1. 如果传递int这种简单类型参数，建议都使用值传递
  2. 如果传递类对象作为参数，则避免隐式类型转换（例如把一个char*转成string，把一个int转成类A对象），全部都在创建线程这一行就构建出临时对象来，然后线程入口函数的形参位置使用引用来作为形参
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#include<iostream>
#include<thread>
using namespace std;

class A {
public:
	A(int a) : m_i(a)
	{
		cout << "A:A(int a) 构造函数执行" << this<<"t_id:"<< std::this_thread::get_id() << endl;
	}
	~A() 
	{
		cout << "A:A(int a) 析构函数执行" << this << "t_id:" << std::this_thread::get_id() << endl;
	}

	A(const A& a)
	{
		cout << "A:A(const A)拷贝构造函数执行" << this << "t_id:" << std::this_thread::get_id() << endl;
	}
	int m_i;

};

void mprint(int i, const A& pmybuf) // 这里必须引用否则两次调用拷贝构造函数
{
	cout << &pmybuf << endl;
}

int main()
{
	int myvar = 1;
	int mysecont = 12;
	std::thread myobj(mprint, myvar,A(mysecont)); // 构造临时对象作为参数传递给线程detach时是安全的
    myobj.join();
	cout << "main thread is running main_id:" << std::this_thread::get_id()  << endl;
	return 0;
}

A:A(int a) 构造函数执行000000F6EA6FFDB4t_id:12056
A:A(const A)拷贝构造函数执行00000262AB335630t_id:12056
A:A(int a) 析构函数执行000000F6EA6FFDB4t_id:12056
00000262AB335630
A:A(int a) 析构函数执行00000262AB335630t_id:22916
main thread is running12056

执行结果，发现哪怕用detach执行，程序没有异常，输出拷贝构造函数，且拷贝构造函数线程id和主线程一致，说明拷贝构造函数发生在主线程执行的过程，使用临时对象作为实参，就可以确保主线程入口的行参数在主线程执行完毕前就已经创建完毕，可以安全使用。

传递类对象

为了数据安全，往线程入口函数传递类类型对象作为参数的时候，不管接收者（形参）是否用引用接收，都一概采用复制对象的方式来进行参数的传递。C++编译器加入了临时对象不能作为非const引用的语义限制，但是如果加上了const要修改类对象成员（一般没必要这么做），就非常不方面，除非每一个类成员变量都加上mutable 。这里可以用一个函数模板 std::ref

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include<iostream>
#include<thread>
using namespace std;

class A {
public:
	A(int a) : m_i(a)
	{
		cout << "A:A(int a) 构造函数执行" << this<<"t_id:"<< std::this_thread::get_id() << endl;
	}
	~A() 
	{
		cout << "A:A(int a) 析构函数执行" << this << "t_id:" << std::this_thread::get_id() << endl;
	}

	A(const A& a)
	{
		cout << "A:A(const A)拷贝构造函数执行" << this << "t_id:" << std::this_thread::get_id() << endl;
	}
	 int m_i;

};

void mprint(int i, const A& pmybuf) // 这里必须引用否则两次调用拷贝构造函数
{
	cout << &pmybuf << endl;
}

void mprint2(A& pmybuf) // 去掉const 
{
	pmybuf.m_i = 198; 
	cout << &pmybuf << endl;
}

int main()
{
	A myobj(10);
	std::thread mytobj(mprint2, std::ref(myobj)); // 用std::ref引用传递 
	mytobj.join(); // 传引用就不能detach

	cout << "main thread is running"<< std::this_thread::get_id()<< endl;
	return 0;
}

用成员函数作为线程入口函数

1
2
3
4
5
6
7
8
9
10
void thread_work(int num)
{
	cout << "子线程 thread_work函数执行 this=" << this << "t_id:" << std::this_thread::get_id() << endl;
}

A myobj(10);
std::thread mytobj(&A::thread_work, &myobj, 7);
mytobj.join();
cout << "main thread is running"<< std::this_thread::get_id()<< endl;
return 0;

互斥量加锁处理共享数据竞争

锁定的代码段越少，执行的效率越高，因为锁住的代码少，执行得快，其他等待锁的线程等待的时间就短

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
#include<iostream>
#include<thread>
#include<mutex>
#include<list>
using namespace std;

class A {
public:
	A()
	{
		
	}
	~A() 
	{
	
	}
	
	void inMsgMessageQue()
	{
		for (int i = 0;i < 10000;i++) {
			cout << "inMsgMessageQue执行插入一个元素" << i << endl;
			my_mutex.lock();  // 操作共享数据先加锁 
			MsgRecvList.push_back(i);
			my_mutex.unlock();  // 共享数据操作完毕解锁
		}
	};

	void outMsgMessageQue()
	{
		int command = 0;
		for (int i = 0;i < 10000;i++) {
			bool result = outMsgProc(command);
			if (result == true) {
				cout << "outMsgMessageQue执行了从容器里取出一个元素" << i << endl;
			}
			else {
				cout << "outMsgMessageQue执行了但是数据是空的" << endl;
			}
		}
	}

	bool outMsgProc(int& command)
	{
		//my_mutex.lock();
		std::lock_guard<std::mutex> sbgard(my_mutex);
		if (!MsgRecvList.empty()) {
			command = MsgRecvList.front();
			MsgRecvList.pop_front();
			//my_mutex.unlock();
			return true;

		}
		//my_mutex.unlock();
		return  false;
	}

	std::mutex my_mutex;
	std::list<int>  MsgRecvList;
};

int main()
{
	A a;

	std::thread inMsg(&A::inMsgMessageQue, &a);
	std::thread outMsg(&A::outMsgMessageQue, &a);
	inMsg.join();
	outMsg.join();


	return 0;
}

std::lock_guardstd::mutex的工作原理，其实它的工作原理很简单，这样理解：在lock_guard类模板的构造函数里，调用了mutex的lock成员函数，而在析构函数里，调用了mutex的unlock成员函数,使用了locak_guard 就不能重复使用 mutext.lock

死锁问题：

多个进程或线程竞争同一不可抢占的资源时，如果每个进程都持有某种资源并等待获取其他资源，就会导致死锁，为了避免死锁，采用有序资源分配法。

死锁演示代码： 创建一个新的互斥两my_mutex2 ,第一个线程 按my_mutex my_mutex2 的顺序加锁 释放锁

第二个线程 按 my_mutex2 my_mutex 的顺序加锁 释放锁

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
#include<iostream>
#include<thread>
#include<mutex>
#include<list>
using namespace std;

class A {
public:
	A()
	{
		
	}
	~A() 
	{
	
	}
	
	void inMsgMessageQue()
	{
		for (int i = 0;i < 10000;i++) {
			cout << "inMsgMessageQue执行插入一个元素" << i << endl;
			my_mutex.lock();  // 操作共享数据先加锁 
			my_mutex2.lock();
			MsgRecvList.push_back(i);
			my_mutex.unlock();  // 共享数据操作完毕解锁
			my_mutex2.unlock();
		}
	};

	void outMsgMessageQue()
	{
		int command = 0;
		for (int i = 0;i < 10000;i++) {
			bool result = outMsgProc(command);
			if (result == true) {
				cout << "outMsgMessageQue执行了从容器里取出一个元素" << i << endl;
			}
			else {
				cout << "outMsgMessageQue执行了但是数据是空的" << endl;
			}
		}
	}

	bool outMsgProc(int& command)
	{
		my_mutex2.lock();
		my_mutex.lock();
		//std::lock_guard<std::mutex> sbgard(my_mutex);
		if (!MsgRecvList.empty()) {
			command = MsgRecvList.front();
			MsgRecvList.pop_front();
			//my_mutex.unlock();
			my_mutex2.unlock();
			my_mutex.unlock();
			return true;

		}
		my_mutex2.unlock();
		my_mutex.unlock();
		//my_mutex.unlock();
		return  false;
	}

	std::mutex my_mutex;
	std::mutex my_mutex2; // 用于死锁演示
	std::list<int>  MsgRecvList;
};

int main()
{
	A a;

	std::thread inMsg(&A::inMsgMessageQue, &a);
	std::thread outMsg(&A::outMsgMessageQue, &a);
	inMsg.join();
	outMsg.join();


	return 0;
}

可以看到某个时刻，程序锁住了，执行不下去了

std::lock函数模版

std::lock函数模板能一次锁住两个或者两个以上的互斥量（互斥量数量是2个到多个，不可以是1个），它不存在多个线程中因为锁的顺序问题导致死锁的风险。

std::lock(my_mutex,my_mutex2);

std::lock_guard参数 std::adopt_lock：

相当于 互斥量已经lock过了，无需要再次lock ，只要在析构函数中执行unlock就可以了

unique_lock

unique_lock和lock_guard一样，都是用来对mutex（互斥量）进行加锁和解锁管理，但是，lock_guard不太灵活：构造lock_guard对象的时候lock互斥量，析构lock_guard对象的时候unlock互斥量。相比之下，unique_lock的灵活性就要好很多，当然，灵活性高的代价是执行效率差一点，内存占用的也稍微多一点

1
2
my_mutex.lock();
std::unique_lock<std::mutex> sbgard1(my_mutex, std::adopt_lock);

unique_lock参数std::try_to_lock ：

开发者不能自己先去lock这个mutex 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
#include<iostream>
#include<thread>
#include<mutex>
#include<list>
using namespace std;

class A {
public:
	A()
	{
		
	}
	~A() 
	{
	
	}
	
	void inMsgMessageQue()
	{
		for (int i = 0;i < 10000;i++) {
			cout << "inMsgMessageQue执行插入一个元素" << i << endl;
			std::unique_lock<std::mutex> sbgard1(my_mutex, std::try_to_lock);

			if (sbgard1.owns_lock()) {
				MsgRecvList.push_back(i);
			}
			else {
				cout << "没有拿到锁，只能干点其他的事情" << endl;
			}
			
		    
		}
	};

	void outMsgMessageQue()
	{
		int command = 0;
		for (int i = 0;i < 10000;i++) {
			bool result = outMsgProc(command);
			if (result == true) {
				cout << "outMsgMessageQue执行了从容器里取出一个元素" << i << endl;
			}
			else {
				cout << "outMsgMessageQue执行了但是数据是空的" << endl;
			}
		}
	}

	bool outMsgProc(int& command)
	{
		
		my_mutex.lock();
		//std::lock_guard<std::mutex> sbgard(my_mutex);
        std::chrono::microseconds dura(200000);
		std::this_thread::sleep_for(dura);
		if (!MsgRecvList.empty()) {
			command = MsgRecvList.front();
			MsgRecvList.pop_front();
			//my_mutex.unlock();
		
			my_mutex.unlock();
			return true;

		}
		my_mutex.unlock();
		
		return  false;
	}

	std::mutex my_mutex;
	std::mutex my_mutex2; // 用于死锁演示
	std::list<int>  MsgRecvList;
};

int main()
{
	A a;

	std::thread inMsg(&A::inMsgMessageQue, &a);
	std::thread outMsg(&A::outMsgMessageQue, &a);
	inMsg.join();
	outMsg.join();


	return 0;
}

unique_lock 参数std::defer_lock

开发者不能自己先去lock这个mutex ，初始化一个没有加锁的mutex

处理一些非共享数据 sbgard1.unlock()

1
2
std::unique_lock<std::mutex> sbgard1(my_mutex, std::defer_lock);
sbgard1.lock(); // unique_lock 能自己解锁，不用自己解，这里只管加锁

release返回它所管理的mutex对象指针，并释放所有权。

一旦解除该unique_lock和所管理的mutex的关联关系，如果原来mutex对象处于加锁状态，则程序员有责任负责解锁。

1
2
3
4
5
std::unique_lock<std::mutex> sbgard1(my_mutex);
// 关联关系解除，开发者只能自己解锁
std::mutex* p_mutex = sbgard1.release();
MsgRecvList.push_back(i);
p_mutex->unlock();  // 只能自己解锁

unique_lock会在离开作用域的时候检查关联的mutex是否lock，如果lock了，unique_lock会帮助程序员unlock

unique_lock所有权的传递

std::unique_lock<std::mutex> sbgard2(std::move(sbgard1));

第二种用函数返回return

1
2
3
4
5
6
7

std::unique_lock<std::mutex> rtn_unique_lock()
{
	std::unique_lock<std::mutex> tmpgaurd(my_mutex);
	return tmpgaurd;
}
std::unique_lock<std::mutex> sbgard3 = rtn_unique_lock();

一个多线线程单例模式案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
#include<iostream>
#include<thread>
#include<mutex>

using namespace std;
std::mutex resource_mutex; 
class MyCAS
{
private:
	MyCAS() {}
    /*
    static void CreateInstance()
	{
		m_instance = new MyCAS();
		static Chuishou c1;
	}
	*/
private:
	static MyCAS* m_instance;

public:
	
	static MyCAS* GetInstance()
	{
		if (m_instance == NULL) {
			std::unique_lock<std::mutex> mymmutex(resource_mutex);
			if(m_instance == NULL) // 双重判断
			{
				m_instance = new MyCAS();
				static Chuishou c1;
			}

		}
        
        	// 用std::call_once 代替 
		/*if (m_instance == NULL)
        {
            std::call_once(g_flag, CreateInstance);
        }*/
        
		return m_instance;
	}

	class Chuishou {
	public:
		~Chuishou()
		{
			if (MyCAS::m_instance)
			{
				delete MyCAS::m_instance;
				MyCAS::m_instance = NULL;
			}
		}
	};

	void func()
	{
		cout << "测试单例" << endl;
	}

};

void mythread()
{
	cout << "我的线程开始执行了" << endl;
	MyCAS::GetInstance()->func();

	cout << "我的线程执行完毕" << endl;
}

MyCAS* MyCAS::m_instance = NULL;

int main()
{
	std::thread mythread1(mythread);
	std::thread mythread2(mythread);
	mythread1.join();
	mythread2.join();
	return 0;
}

condition_variable、wait、notify_one与notify_all

线程A中等待一个条件满足（如等待消息队列中有要处理的数据），另外还有个线程B（专门往消息队列中扔数据），当条件满足时（消息队列中有数据时），线程B通知线程A，那么线程A就会从等待这个条件的地方往下继续执行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
#include<iostream>
#include<thread>
#include<mutex>
#include<list>
using namespace std;
class A {
public:


	void inMsgRecvQueue()
	{
		for (int i = 0;i < 10000;i++)
		{
			cout << "inMsgRecvQueue 执行，插入一个元素" << i << endl;
			std::unique_lock<std::mutex> sbguard1(my_mutex);
			MsgRecvList.push_back(i);

		}
		return;
	};


	void inMsgRecvCondQueue()
	{
		for (int i = 0;i < 10000;i++)
		{
			cout << "inMsgRecvQueue 执行，插入一个元素" << i << endl;
			std::unique_lock<std::mutex> sbguard1(my_mutex);
			MsgRecvList.push_back(i);
			my_cond.notify_one();
		}
		return;

	};



	bool outMsgLURProc(int& command)
	{
		if (!MsgRecvList.empty()) {
			std::unique_lock<std::mutex> sbguard1(my_mutex);
			if (!MsgRecvList.empty())
			{
				command = MsgRecvList.front(); // 返回第一个元素，但不检查元素是否存在
				MsgRecvList.pop_front(); // 移除第一个元素，但不返回
				return true;
			}
		}
		return false;
	}


	void outMsgRecvQueue()
	{
		int command = 0;
		for (int i = 0;i < 10000;i++)
		{
			bool result = outMsgLURProc(command);
			if (result == true)
			{
				cout << "outMsgRecvQueue从容器取出一个元素" << command << endl;
			}
			else {
				cout << "outMsgRecvQueue执行了但是目前消息队列数据为空" << endl;
			}
		}
		cout << "end" << endl;
		return;
	}

	void outMsgRecvCondQueue()
	{
		int command = 0;
		while (true)
		{
			std::unique_lock<std::mutex> sbguard1(my_mutex);
			my_cond.wait(sbguard1, [this] {
				if (!MsgRecvList.empty())
				{
					return true;
				}
				return false;
			});
			command = MsgRecvList.front(); // 返回第一个元素，但不检查元素是否存在
			MsgRecvList.pop_front(); // 移除第一个元素，但不返回
			sbguard1.unlock();
			cout << "outMsgRecvCondQueue" << command << endl;
		}
		return;
	}

	

	std::mutex my_mutex;
	std::list<int> MsgRecvList;

private:
	std::condition_variable my_cond;
};
int main()
{
	A myobja;
	std::thread myOutObj(&A::outMsgRecvCondQueue, &myobja);
	std::thread myInObj(&A::inMsgRecvCondQueue, &myobja);

	myOutObj.join();
	myInObj.join();
	
	cout << "main 主线程执行完毕" << endl;


	return 0;
}


std::async和std::future的用法

std::async是一个函数模板，通常的说法是用来启动一个异步任务，启动起来这个异步任务后，它会返回一个std::future对象（std::future是一个类模板）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include<iostream>
#include<future>
using namespace std;

int mythread()
{
	cout << "mythead start threadId is " << std::this_thread::get_id() << endl;
	std::chrono::microseconds dura(20000); // 20秒
	std::this_thread::sleep_for(dura);
	cout << "mythrad_ end threadId" << std::this_thread::get_id() << endl;
	return 5;

}
int main()
{
	std::future<int> result = std::async(mythread); // 流程不会卡在这里，如果有参数放入第二个位置

	cout << result.get() << endl; // 线程卡在这里等待线程执行完,否则执行报错异常
	//result.wait(); 只等待线程返回不返回结果
	return 0;
}

std::async 额外参数

std::launch::deferred 不创建新线程且延迟调用

1
std::future<int> result = std::async(std::launch::deferred,&A::mythread, &a, temppar);

调用get 或wait后发现mythread 被执行了，但是子线程和主线程id相同，说明并没有创建新的线程，而是在主线程调用的mythread

std::launch::async

1
std::future<int> result = std::async(std::launch::async,&A::mythread, &a, temppar);

调用async后线程会创建并立即执行线程

1
std::future<int> result = std::async(std::launch::async | std::launch::deferred,&A::mythread, &a, temppar);

“|“ 表示创建新线程并执行或者没有创建新新线程且延迟调用，系统根据一定因素去评估，自行选择（相当于不用任何参数）

std::async 是异步任务可创建线程也可不创建线程，和std::thread不同 ，在资源紧张时候可以用async代替 thread

std::packaged_task

这是一个模版类，模版参数是各种可调用对象，通过packaged_task 把各种可调用对象包装起来，方便将来作为线程入口函数调用

1
2
3
4
5
6
7
8
9
cout << "main threadid = " << std::this_thread::get_id() << endl;
std::packaged_task<int(int)> mypt(mythread);  // 把函数mythread 通过 packaged_task 包装起来

std::thread t1(std::ref(mypt), 1); // 线程直接开始执行，第二个参数作为线程入口函数的参数
t1.join(); // 可以调用这个等待线程执行完毕，不调用这个不行，程序会崩溃
std::future<int> result = mypt.get_future();

cout << result.get() << endl;
cout << "main 主函数执行结果！" << endl;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
int main()
{
	cout << "main threadid = " << std::this_thread::get_id() << endl;
	std::packaged_task<int(int)> mypt([](int mypar)
	{
			cout << mypar << endl;
			cout << "lambda mythread() start" << std::this_thread::get_id() << endl;
			std::chrono::milliseconds dura(5000);
			std::this_thread::sleep_for(dura);
			cout << "lambda mythrad() end" << std::this_thread::get_id() << endl;
			return 15;

	});  // 

	//入 容器
	mytasks.push_back(std::move(mypt));  // 移动语义
	// 出容器
	std::packaged_task<int(int)> mypt2;
	auto iter = mytasks.begin();
	mypt2 = std::move(*iter);    // 用移动语义
	mytasks.erase(iter);   // 删除第一个元素
	mypt2(124);  // 直接调用
	// 借用future 取得结果
	std::future<int> result = mypt2.get_future();
	cout << result.get() << endl;
	cout << "main 主函数执行结果！" << endl;
  
	return 0;
}

这个 案例好复杂，学c++ 后，一直没理解为什么这些大神搞这么多的模版函数,其实工作还是用最简单的std:: thread 就可以搞定。

std::promise

这个类模版，能够在某个线程中为其赋值，然后就可以在其他线程中，把这个值取出来

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
void mythread(std::promise<int> & tmpp,int calc)
{
	
	cout << "mythread() start:" << std::this_thread::get_id() << endl;
	calc++;
	calc *= 10;
	std::chrono::milliseconds dura(5000);
	std::this_thread::sleep_for(dura);

	int result = calc;
	tmpp.set_value(result);  // 保存结果
	cout << "mythread end" << std::this_thread::get_id() << endl;
}



int main()
{
	cout << "main" << std::this_thread::get_id() << endl;
	std::promise<int> mypro;
	// 创建一个线程t1 将函数机对象myprom作为参数放进去
	std::thread t1(mythread, std::ref(mypro), 180);
	t1.join();  // 等待线程执行完毕 
	// 获取结果值
	std::future<int> ful = mypro.get_future();  
	auto result = ful.get();  // 获取值 只能一次

	cout << "result=" << result << endl;
  
	return 0;
}

总结下来就是通过promis保存一个值，在将来某个时刻把一个future绑定到这个promise上

future其他成员函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#include<iostream>
#include<thread>
#include<mutex>

#include<future>
#include<vector>
using namespace std;


int mythread()
{
	
	cout << "mythread() start:" << std::this_thread::get_id() << endl;
	
	std::chrono::milliseconds dura(5000);
	std::this_thread::sleep_for(dura);

	cout << "mythread end" << std::this_thread::get_id() << endl;
	return 1;
}



int main()
{
	cout << "main" << std::this_thread::get_id() << endl;
	std::future<int> result = std::async(mythread);
	cout << "continue...." << endl;

	// future_status 看做一个枚举
	std::future_status status = result.wait_for(std::chrono::seconds(1)); //等待一秒钟
	
	if (status == std::future_status::timeout) 
	{
		// 超时线程
		cout << "超时线程没有执行完" << endl;
		cout << result.get() << endl;
	}
	else if (status == std::future_status::ready)
	{
		cout << "线程成功执行完毕并返回!" << endl;
	}
	else if (status == std::future_status::deferred)
	{
		cout << "线程被延迟执行" << endl;
	}
	
	cout << "main 主函数执行结果" << endl;
	return 0;
}

std::shared_future

shared_future的get函数把数据进行复制而不是转移

1
2
3
4
	std::shared_future<int> result_s(std::move(result));
	result.valid() // false
		result_s.valid(); // ture
resut_s.get() // 可以调用多次

原子操作

用互斥量mutex 处理共享变量，效率很低，互斥量更适合对一段代码加锁，对单个共享变量我们用std::atomic

atomic 用法非常简单

1
2
3
4
5
std::atomic<int> g_mycout = 0;

g_mycout++ // 对应的的操作是原子操作
g_mycout+=1 // 原子操作
g_mycout= g_mycout+1 // 不是原子操作

recursive_mutex递归的独占互斥量

1
2
std::recursive_mutex my_mutext;
std::lock_gurad<std::recursive_mutex>sbguard(std::my_mutext);

std::timed_mutex是带超时功能的独占互斥量

是try_lock_for

一个是try_lock_until

1
2
3
4
5
6
7
8
9
std::chrono::milliseconds timeout(100);
if (my_mutex.try_lock_for(timeout)) {
	// ....
}

if (my_mutex.try_lock_until(chrono::steady_clock::now()+ timeout)) {
	// ....
}

std::recursive_timed_mutex是带超时功能的递归的独占互斥量

参考文献：《C++新经典》

赏

谢谢你请我吃臭豆腐

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主技术栈go/kubernetes,业余搞C++,