网站建设职业去哪里上班,0531建设网站,深圳宝安中学家长群,wordpress 摘要函数文章目录why atomic?sequentially consistent atomicRelaxed memory modelswhy atomic?
当我们有一片内存空间S,线程A正在往S里写数据,这个时候线程B突然往S中做了操作,导致线程A的操作结果变得不可预知(对线程A来说),这种情况换句话说叫做data race,我们一般的操作时上锁,在…
文章目录why atomic?sequentially consistent atomicRelaxed memory modelswhy atomic?
当我们有一片内存空间S,线程A正在往S里写数据,这个时候线程B突然往S中做了操作,导致线程A的操作结果变得不可预知(对线程A来说),这种情况换句话说叫做data race,我们一般的操作时上锁,在c中有多种类型的锁比如std::mutex,std::shared_mutex(c 17), std::mutex的性能要比std::shared_mutex低,因为std::shared_mutex上锁后其他线程可以照样可以访问被lock住的空间(只可以读原数据)而一旦线程对一块内存区域上std::mutex锁后其他的线程无论读还是写都不会成功 mutext使用如下
#include iostream
#include mutex
#include threadclass A{public:A() default;~A() default;void add_element(int num);static int element;
private:std::mutex m;};int A::element 0;void A::add_element(int num){m.lock();std::cout thread std::this_thread::get_id() add num std::endl;element element num;m.unlock();
}int main(){A a;std::thread worker[5];for(int i 0; i 5; i){worker[i] std::thread(A::add_element, std::addressof(a), i);worker[i].join();}}注意 如果std::thread()添加的函数对象在class外部且调用std::thread()的函数也不属于任何一个class那么就直接调用std::thread()第二个参数佳被调用函数的第一个参数 如果std::thread()添加的函数对象在class内部(class 内部非静态函数如我们上面的例子所示)他要除了要将函数的全部名称(包含class名字)写上去还要指定我们这个class对象的位子这样才能寻址到指定的函数std::thread()第三个就是该被注册函数的第一个参数 如果std::thread()位于某个class内部且注册的函数也位于这个class内部我们和上面一样需要指定这个class的起使位子(this在std::thread()的第二个参数中) shared_mutext使用如下
#include iostream
#include shared_mutex
#include threadclass A{public:A() default;~A() default;void add_element(int num);void get_element();static int element;
private:std::shared_mutex m;};int A::element 0;void A::add_element(int num){//for set lockm.lock();element element num;m.unlock();
}void A::get_element(){//for read lockm.lock_shared();std::cout thread std::this_thread::get_id() get element element std::endl;m.unlock_shared();
}int main(){A a;std::thread worker[5];for(int i 0; i 5; i){worker[i] std::thread(A::add_element, std::addressof(a), i);worker[i].join();worker[i] std::thread(A::get_element, std::addressof(a));worker[i].join();}}现在回归正题为什么我们要使用atomic而不是锁?首先我们在用atomic的时候发现系统明显的慢并且我们的锁颗粒已经小到极致那么为了再进一步的提升性能我们只能使用atomic 首先锁的一些操作都是操作系统提供比如winlinux但是atomic是我们处理器提供的锁机制其实是将被lock住的线程挂起空出cpu资源给其他的线程但是这有明显的inter pross的线程上下文切换被锁住的线程在不断地尝试直到成功强到锁(也叫做busy wait)我们使用锁的时候还要考虑死锁等情况发生(当然c中有lock_guardclass将一个锁包住当lock_guardclass对象被销毁自动的unlock)
而我们的atomic就简单的多只需要将容易发生race的那个变量置为atomic即可
#include iostream
#include shared_mutex
#include thread
#include chrono
#include atomicclass A{public:A() default;~A() default;void add_element(int num);void get_element();static std::atomicint element;
private://std::shared_mutex m;};std::atomicint A::element{0};void A::add_element(int num){//for set lock//m.lock();element element num;//m.unlock();
}void A::get_element(){//for read lock//m.lock_shared();std::cout thread std::this_thread::get_id() get element element std::endl;//m.unlock_shared();
}int main(){A a;std::vectorstd::thread worker;for(int i 0; i 5; i){worker.push_back(std::thread(A::add_element, std::addressof(a), i));}for(int i 5; i 10; i){worker.push_back(std::thread(A::get_element, std::addressof(a)));}for(auto currth : worker){currth.join();}return 0;
}atomic 在C标准中并没有说明他是lock-free的有的平台他是lock-free有的平台他是用mutex实现所以C提供了一个method去验证你的这个平台上atomic 是否是lock-free
bool std::atomic::is_lock_free()Lock-free usually applies to data structures shared between multiple threads, where the synchronisation mechanism is not mutual exclusion; the intention is that all threads should keep making some kind of progress instead of sleeping on a mutex. sequentially consistent atomic
首先如果使用了atomicT,那么C是可以保证sequentially consistent atomic特性的 什么是sequentially consistent atomic他所保证的特性如下
所有线程的operation中load和store操作是对所有其他线程可见的必须要遵从(源码)顺序执行
比如我们有2个threadA和B其中A执行如下2个操作
thread A
x.store(1);
reg1 y.load();线程B执行以下2个操作
thread B
y.store(2);
reg2 x.load();假设上述的2个线程的操作遵循sequentially consistent atomic那么他们的load和store指令是相互可见的(满足条件1)并且每个线程执行atomic operate的顺序严格按照上述伪代码(满足条件2对于线程A x.store在前y.load在后对于线程B y.store在前,x.load在这些顺序不能变)那么他们的执行顺序有6种可能
A:x.store(1)---B:y.store(2)---A:reg1y.load()---B:reg2x.load()
A:x.store(1)---B:y.store(2) --B:reg2x.load() --A:reg1y.load()
A:x.store(1)---A:reg1y.load()--B:y.store(2)--B:reg2x.load()
B:y.store(2)---A:x.store(1)--A:reg1y.load()---B:reg2x.load()
B:y.store(2)---A:x.store(1)--B:reg2x.load()--A:reg1y.load()
B:y.store(2)---B:reg2x.load()---A:x.store(1)--A:reg1y.load()再比如我们2个线程1和2执行下面的指令
线程1指令
x.store(2)
x.load()线程2指令
x.store(3)因为load指令是对所有其他线程可见所以线程1可以看到自己的load指令也可以看到线程2的load指令(限制1)那么执行顺序有3种如下(假设x初始化为1)
1:x.store(2)---2:x.store(3)---1:x.load() 结果X5
2:x.store(3)---1:x.store(2)---1:x.load() 结果X5
1:x.store(2)---1:x.load()---2:x.store(3) 结果X22:x.store(3)---1:x.load()---1:x.store(2) 结果X3上述的顺序永远不会出现因为1:x.load()不能出现在1:x.store(2)之前否则违反规则2(代码中规定了执行顺序)
此时你也许会问这有啥用要知道c原子操作只会在操作atomic T A 的时候是原子的如下代码
#include iostream
#include thread
#include atomicclass A{public:A() default;~A() default;void for_thread_1();void for_thread_2();void for_thread_3();static std::atomicint element;
private:};std::atomicint A::element{0};void A::for_thread_1(){element element 2;std::cout for thread 1 element is element std::endl;
}void A::for_thread_2(){element element 3;//std::cout for thread 2 element is element std::endl;
}int main(){A a;std::thread worker[3];worker[0] std::thread(A::for_thread_1, std::addressof(a));worker[1] std::thread(A::for_thread_2, std::addressof(a));worker[0].join();worker[1].join();
如果说我们想要线程1强制在线程2之后执行(结果为5)也就是下面这个顺序
2:x.store(3)---1:x.store(2)---1:x.load() 结果X5可以这样写
#include iostream
#include thread
#include atomicclass A{public:A() default;~A() default;void for_thread_1();void for_thread_2();void for_thread_3();static std::atomicint element;
private:};std::atomicint A::element{0};void A::for_thread_1(){while(element 0) continue;element element 2;std::cout for thread 1 element is element std::endl;
}void A::for_thread_2(){element element 3;//std::cout for thread 2 element is element std::endl;
}int main(){A a;std::thread worker[3];worker[0] std::thread(A::for_thread_1, std::addressof(a));worker[1] std::thread(A::for_thread_2, std::addressof(a));worker[0].join();worker[1].join();return 0;
}注意c原子操作一定是在对原子对象操作一瞬间是原子的比如上述例子中线程1和线程2中每一个对原子对象element操作的句子 也许你还会疑问以为线程1对element操作的2个语句是一个原子操作其实这是2个原子操作分别是store和load我们c atomic如果不做特殊的设置默认Sequential consistency Sequential consistency也是分布式领域大牛2013年图灵奖获得者强分布式一致性协议paxos的发明者 Leslie Lamport发明的 Relaxed memory models
TODO
