C++11线程指南（6）--共享内存与互斥⽬录
1. 共享内存
先回顾⼀下前⾯⼏章中⽤到的，⼀个存在资源竞争的例⼦：
#include<iostream>
#include<thread>
void ThreadFunc() {
for (int i = 1; i <= 8; ++i)
std::cout << "thread function: " << i << "\n";
}
int main()
{
std::thread thr(&ThreadFunc);
for (int i = 1; i <= 8; ++i)
std::cout << "main thread: " << i << "\n";
thr.join();
return 0;
}
运⾏结果为：
main thread: 1
main thread: 2
main thread: 3
main thread: 4
main thread: 5
main thread: 6
thread技术main thread: 7
thread function: main thread: 8
1
thread function: 2
thread function: 3
thread function: 4
thread function: 5
thread function: 6
thread function: 7
thread function: 8
可以看到，结果是⽆序的。
2.使⽤互斥量mutex
下⾯使⽤互斥对线程间进⾏同步。
std::mutex mu;
void PrintFunc(std::string msg, int id) {
mu.lock();
std::cout<<msg<<":"<<id<<std::endl;
mu.unlock();
}
void ThreadFunc() {
for(int i=1;i<=8;++i)
PrintFunc("thread function", i);
}
int main()
{
std::thread thr(&ThreadFunc);
for(int i=1;i<=8;++i)
PrintFunc("main thread", i);
thr.join();
return 0;
}
运⾏结果为：
main thread:1
thread function:1
thread function:2
thread function:3
main thread:2
main thread:3
main thread:4
thread function:4
thread function:5
thread function:6
main thread:5
main thread:6
main thread:7
main thread:8
thread function:7
thread function:8
3.共享数据问题
多线程之间共享数据的问题，很⼤程度上源⾃对数据的修改顺序。
如果共享数据是只读的，则不会存在问题，因为⼀个线程读数据不会影响到另⼀个线程读取相同数据。但是，但⼀个线程或多个线程可以修改数据时，问题就出现了。
下⾯介绍的互斥就是⽤于解决这种问题的。
4.互斥量mutex释放
下⾯例⼦中多个线程同时访问相同的list
std::list<int> myList;
void AddToList(int max, int interval) {
for(int i=0;i<max;++i) {
if(i%interval==0)
myList.push_back(i);
}
}
void PrintList() {
for(auto &iter: myList)
std::cout<<iter<<",";
}
int main() {
int max = 15;
std::thread t1(AddToList, max, 1);
std::thread t2(AddToList, max, 2);
std::thread t3(PrintList);
t1.join();
t2.join();
t3.join();
return 0;
}
运⾏结果为：
0,2,4,6,8,10,12,14,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,
或者
0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,0,2,4,6,8,10,12,14,
在对list的操作过程中，t1会插⼊0到9的整数，⽽t2会插⼊每个2的倍数。同时，t3会打印list元素。上⾯的运⾏结果显⽰，打印完全处于⽆序状态。
互斥可以说是C++的数据保护中使⽤最⼴泛的技术。它可以保护数据，避免资源竞争，但同时也会带来死锁，或者保护了太多的或太少的数据（互斥范围选择），等问题。
C++中可以使⽤std::mutex()创建实例，调⽤lock()来锁定资源，unlock()释放资源。但是，可能存在unLock()没有被调⽤进⾏释放。  例如，lock()之后并且unlock()之前，抛出了⼀个异常。这样导致资源⼀直处于被锁状态。所以，在标准C++库中，提供了
std::lock_guard类模板。它在构造时会锁定指定的mutex, 析构时解锁，确保⼀个锁定的资源最后都能解锁。
#include<mutex>
std::list<int> myList;
std::mutex myMutex;
void AddToList(int max, int interval) {
std::lock_guard<std::mutex> guard(myMutex);
for(int i=0;i<max;++i) {
if(i%interval==0)
myList.push_back(i);
}
}
void PrintList() {
std::lock_guard<std::mutex> guard(myMutex);
for(auto &iter: myList)
std::cout<<iter<<",";
}
int main() {
int max = 15;
std::thread t1(AddToList, max, 1);
std::thread t2(AddToList, max, 2);
std::thread t3(PrintList);
t1.join();
t2.join();
t3.join();
return 0;
}
运⾏的其中⼀种结果为：
0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,0,2,4,6,8,10,12,14,
从上看到，2的整数倍的数是连续的。加了互斥机制后，保证了多线程的顺序性。

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。