原子操作及对C++编程的意义

最新推荐文章于 2023-08-23 09:22:17 发布
最新推荐文章于 2023-08-23 09:22:17 发布
阅读量648 收藏 2
点赞数
分类专栏： C++

原子操作及对C++编程的意义



前言     


      所谓原子操作，就是“不可中断的一个或一系列操作”。

      在单核心处理器系统中，能够在一条机器指令中完成的操作都可以认为是原子操作，因为中断只能发生于指令之间。这也是某些CPU指令系统中引入了test_and_set、test_and_clear等指令用于临界资源互斥的原因。
在对称多处理器(Symmetric Multi-Processor)结构中就不同了，由于系统中有多个处理器在独立地运行，即使能在单条指令中完成的操作也有可能受到干扰。

CPU对原子操作的影响

intel处理器

      《Intel 64 and IA-32 Architectures Software Developer`s Manual》Volume3 System Programming Guide，8.1.1 Guaranteed Atomic Operations中讲解的原子操作如下：

      Intel486处理器（以及以后生产的处理器）确保以下对基本存储器的操作行为为原子操作：
      Reading or writing a byte
      读写一个byte
      Reading or writing a word aligned on a 16-bit boundary
      读写16bit(2byte)内存对齐的字(word)
      Reading or writing a doubleword aligned on a 32-bit boundary
      读写32bit(4byte)内存对齐的双字(dword)
      The Pentium processor (and newer processors since) guarantees that the following additional memory operationswill always be carried out atomically:
      Pentium系列处理器（以及以后生产的处理器）确保以下对基本存储器的操作行为为原子操作：
      Reading or writing a quadword aligned on a 64-bit boundary
      读写64bit(8byte)内存对齐的四字(quadword)
      16-bit accesses to uncached memory locations that fit within a 32-bit data bus
      使用16bit访问的未缓存的内存,并且这些内存适应32位数据总线（翻译不好）
      The P6 family processors (and newer processors since) guarantee that the following additional memory operationwill always be carried out atomically:
      P6系列处理器（以及以后生产的处理器）确保以下对基本存储器的操作行为为原子操作：
      Unaligned 16-, 32-, and 64-bit accesses to cached memory that fit within a cache line
      对单个cache line中缓存地址的未对齐的16/32/64位访问（非对齐的数据访问非常影响性能）
      Accesses to cacheable memory that are split across cache lines and page boundaries are not guaranteed to beatomic by the Intel Core 2 Duo, Intel®Atom™, Intel Core Duo, Pentium M, Pentium 4, Intel Xeon, P6 family, Pentium, and Intel486 processors. The Intel Core 2 Duo, Intel Atom, Intel Core Duo, Pentium M, Pentium 4, IntelXeon, and P6 family processors provide bus control signals that permit external memory subsystems to make splitaccesses atomic; however, nonaligned data accesses will seriously impact the performance of the processor andshould be avoided.
     那些被总线带宽、cache line以及page大小给分隔开了的内存地址的访问不是原子的，你如果想保证这些操作是原子的，你就得求助于机制Bus Lock，对总线发出相应的控制信号才行。
      An x87 instruction or an SSE instructions that accesses data larger than a quadword may be implemented usingmultiple memory accesses. If such an instruction stores to memory, some of the accesses may complete (writingto memory) while another causes the operation to fault for architectural reasons (e.g. due an page-table entry thatis marked “not present”). In this case, the effects of the completed accesses may be visible to software eventhough the overall instruction caused a fault. If TLB invalidation has been delayed (see Section 4.10.4.4), suchpage faults may occur even if all accesses are to the same page.

     在intel处理器上c++中一些基本的运算那些是基本操作？（本人CPU为Intel Core i5-4590 3.3GHz， x, y均为int型)

操作
反汇编代码(VS2010)                    
++imov         eax,dword ptr [i]  
add         eax,1  
mov         dword ptr [i],eax
i++mov         eax,dword ptr [i]  
add         eax,1  
mov         dword ptr [i],eax
x = ymov         eax,dword ptr [y]  
mov         dword ptr [x],eax
x = 1mov         dword ptr [x],1
x + ymov         eax,dword ptr [x]  
add         eax,dword ptr [y]
x + 1mov         eax,dword ptr [x]  
add         eax,1
x += ymov         eax,dword ptr [x]  
add         eax,dword ptr [y]  
mov         dword ptr [x],eax
x += 1mov         eax,dword ptr [x]  
add         eax,1  
mov         dword ptr [x],eax 
x - ymov         eax,dword ptr [x]  
sub         eax,dword ptr [y] 
x - 1mov         eax,dword ptr [x]  
sub         eax,1
x -= ymov         eax,dword ptr [x]  
sub         eax,dword ptr [y]  
mov         dword ptr [x],eax
x -= 1mov         eax,dword ptr [x]  
sub         eax,1  
mov         dword ptr [x],eax
x * ymov         eax,dword ptr [x]  
imul        eax,dword ptr [y]
x * 10(x*1和x*2会被优化)mov         eax,dword ptr [x]  
imul        eax,eax,0Ah
x *= ymov         eax,dword ptr [x]  
imul        eax,dword ptr [y]  
mov         dword ptr [x],eax
x *= 10mov         eax,dword ptr [x]  
imul        eax,eax,0Ah  
mov         dword ptr [x],eax
x / ymov         eax,dword ptr [x]  
cdq  
idiv        eax,dword ptr [y]
x / 10mov         eax,dword ptr [x]  
cdq  
mov         ecx,0Ah  
idiv        eax,ecx
10 / xmov         eax,0Ah  
cdq  
idiv        eax,dword ptr [x]
x /= ymov         eax,dword ptr [x]  
cdq  
idiv        eax,dword ptr [y]  
mov         dword ptr [x],eax
x /= 10mov         eax,dword ptr [x]  
cdq  
mov         ecx,0Ah  
idiv        eax,ecx  
mov         dword ptr [x],eax
x % ymov         eax,dword ptr [x]  
cdq  
idiv        eax,dword ptr [y]
x % 10mov         eax,dword ptr [x]  
cdq  
mov         ecx,0Ah  
idiv        eax,ecx
x %= ymov         eax,dword ptr [x]  
cdq  
idiv        eax,dword ptr [y]  
mov         dword ptr [x],edx
x %= 10mov         eax,dword ptr [x]  
cdq  
mov         ecx,0Ah  
idiv        eax,ecx  
mov         dword ptr [x],edx
x >> ymov         eax,dword ptr [x]  
mov         ecx,dword ptr [y]  
sar         eax,cl
x >> 1mov         eax,dword ptr [x]  
sar         eax,1
x << ymov         eax,dword ptr [x]  
mov         ecx,dword ptr [y]  
shl         eax,cl
x << 1mov         eax,dword ptr [x]  
shl         eax,1
x >>= ymov         eax,dword ptr [x]  
mov         ecx,dword ptr [y]  
sar         eax,cl  
mov         dword ptr [x],eax
x >>= 1mov         eax,dword ptr [x]  
sar         eax,1  
mov         dword ptr [x],eax
x <<= ymov         eax,dword ptr [x]  
mov         ecx,dword ptr [y]  
shl         eax,cl  
mov         dword ptr [x],eax
x <<= 1mov         eax,dword ptr [x]  
shl         eax,1  
mov         dword ptr [x],eax
x & ymov         eax,dword ptr [x]  
and         eax,dword ptr [y]
x & 10mov         eax,dword ptr [x]  
and         eax,0Ah
x &= ymov         eax,dword ptr [x]  
and         eax,dword ptr [y]  
mov         dword ptr [x],eax
x &= 10mov         eax,dword ptr [x]  
and         eax,0Ah  
mov         dword ptr [x],eax
x | ymov         eax,dword ptr [x]  
or          eax,dword ptr [y] 
x | 10mov         eax,dword ptr [x]  
or          eax,0Ah
x |= ymov         eax,dword ptr [x]  
or          eax,dword ptr [y]  
mov         dword ptr [x],eax
x |= 10mov         eax,dword ptr [x]  
or          eax,0Ah  
mov         dword ptr [x],eax
x ^ ymov         eax,dword ptr [x]  
xor         eax,dword ptr [y] 
x ^ 10mov         eax,dword ptr [x]  
xor         eax,0Ah
x ^= ymov         eax,dword ptr [x]  
xor         eax,dword ptr [y]  
mov         dword ptr [x],eax
x ^= 10mov         eax,dword ptr [x]  
xor         eax,0Ah  
mov         dword ptr [x],eax
!xxor         eax,eax  
cmp         dword ptr [x],0  
sete        al
~xmov         eax,dword ptr [x]  
not         eax
从图表中看出就 x = 1为一条汇编操作指令。那我们再来看下不同类型下的的值为x赋值的结果：

类型反汇编代码（vs2010）
char x = 10;mov         byte ptr [x],0Ah
unsigned char x = 10;mov         byte ptr [x],0Ah
short x = 10;mov         eax,0Ah  
mov         word ptr [x],ax
unsigned short x = 10;mov         eax,0Ah  
mov         word ptr [x],ax
int x = 10;mov         dword ptr [x],0Ah
unsigned int x = 10;mov         dword ptr [x],0Ah
long x = 10;mov         dword ptr [x],0Ah
unsigned long x = 10;mov         dword ptr [x],0Ah
long long x = 0xFFFFFFFFFFFF;mov         dword ptr [x],0FFFFFFFFh  
mov         dword ptr [ebp-8],0FFFFh
unsigned long long x = 0xFFFFFFFFFFFF;mov         dword ptr [x],0FFFFFFFFh  
mov         dword ptr [ebp-8],0FFFFh
float x = 10.20;fld         dword ptr [__real@41233333 (0F6311Ch)]  
fstp        dword ptr [x]
double x = 10.20;fld         qword ptr [__real@4024666666666666 (13D3120h)]  
fstp        qword ptr [x]
__int8 x = 10;
mov         byte ptr [x],0Ah
__int16 x = 10;
mov         eax,0Ah  
mov         word ptr [x],ax
__int32 x = 10;
mov         dword ptr [x],0Ah  
__int64 x = 0xFFFFFFFFFFFF;
mov         dword ptr [x],0FFFFFFFFh  
mov         dword ptr [ebp-8],0FFFFh

C++中线程同步


什么情况需要线程同步

1、有两个或两个以上的线程对同一份数进行操作，而且这些线程中存在写操作。

2、每个线程对该数据的操作完成后才能进行其他线程对该数据的操作，也就是乱序会对数据产生”撕裂“或数据难以预料。

比如说一个结构体重有两个成员变量{int x; int y;}， 如果一个线程对该结构体的实例进行写操作{x = 1, y = 2}，另一个也进行写操作{x = 3, y = 4}；如果没有进行线程同步，会存在如下几种情况：

x = 1y =2
x = 1y =4
x = 3y =2
x = 3y = 4
这样会造成数据的”撕裂“，从而需要我们进行线程同步保证数据要么是 {x = 1, y = 2}，要么是 {x = 3, y = 4}。

在C++中面对内建类型的多线程同步，非原子操作并不一定需要线程同步


操作反汇编代码(VS2010)  
说明                                                 
同步？
++imov         eax,dword ptr [i]  
add         eax,1  
mov         dword ptr [i],eax		存在对同一数据的读写， 乱序会造成数据异常需要
i++mov         eax,dword ptr [i]  
add         eax,1  
mov         dword ptr [i],eax		同上需要
x = ymov         eax,dword ptr [y]  
mov         dword ptr [x],eax		非对同一数据的读写，而且乱序不会对数据结果产生影响不需要
x = 1mov         dword ptr [x],1本来就是原子操作不需要
x + ymov         eax,dword ptr [x]  
add         eax,dword ptr [y]		x + y不赋值给其他变量是没有意义的，不做讨论 
x + 1mov         eax,dword ptr [x]  
add         eax,1		不赋值给其他变量是没有意义的，不做讨论 
x += ymov         eax,dword ptr [x]  
add         eax,dword ptr [y]  
mov         dword ptr [x],eax		存在对同一数据的读写， 乱序会造成数据异常需要
x += 1mov         eax,dword ptr [x]  
add         eax,1  
mov         dword ptr [x],eax 		存在对同一数据的读写， 乱序会造成数据异常需要
x - ymov         eax,dword ptr [x]  
sub         eax,dword ptr [y] 		不赋值给其他变量是没有意义的，不做讨论 
x - 1mov         eax,dword ptr [x]  
sub         eax,1		不赋值给其他变量是没有意义的，不做讨论 
x -= ymov         eax,dword ptr [x]  
sub         eax,dword ptr [y]  
mov         dword ptr [x],eax		存在对同一数据的读写， 乱序会造成数据异常需要
x -= 1mov         eax,dword ptr [x]  
sub         eax,1  
mov         dword ptr [x],eax		存在对同一数据的读写， 乱序会造成数据异常需要
x * ymov         eax,dword ptr [x]  
imul        eax,dword ptr [y]		不赋值给其他变量是没有意义的，不做讨论 
x * 10(x*1和x*2会被优化)mov         eax,dword ptr [x]  
imul        eax,eax,0Ah		不赋值给其他变量是没有意义的，不做讨论 
x *= ymov         eax,dword ptr [x]  
imul        eax,dword ptr [y]  
mov         dword ptr [x],eax		存在对同一数据的读写， 乱序会造成数据异常需要
x *= 10mov         eax,dword ptr [x]  
imul        eax,eax,0Ah  
mov         dword ptr [x],eax		存在对同一数据的读写， 乱序会造成数据异常需要
x / ymov         eax,dword ptr [x]  
cdq  
idiv        eax,dword ptr [y]		不赋值给其他变量是没有意义的，不做讨论 
x / 10mov         eax,dword ptr [x]  
cdq  
mov         ecx,0Ah  
idiv        eax,ecx		不赋值给其他变量是没有意义的，不做讨论 
10 / xmov         eax,0Ah  
cdq  
idiv        eax,dword ptr [x]		不赋值给其他变量是没有意义的，不做讨论 
x /= ymov         eax,dword ptr [x]  
cdq  
idiv        eax,dword ptr [y]  
mov         dword ptr [x],eax		存在对同一数据的读写， 乱序会造成数据异常需要
x /= 10mov         eax,dword ptr [x]  
cdq  
mov         ecx,0Ah  
idiv        eax,ecx  
mov         dword ptr [x],eax		存在对同一数据的读写， 乱序会造成数据异常需要
x % ymov         eax,dword ptr [x]  
cdq  
idiv        eax,dword ptr [y]		不赋值给其他变量是没有意义的，不做讨论 
x % 10mov         eax,dword ptr [x]  
cdq  
mov         ecx,0Ah  
idiv        eax,ecx		不赋值给其他变量是没有意义的，不做讨论 
x %= ymov         eax,dword ptr [x]  
cdq  
idiv        eax,dword ptr [y]  
mov         dword ptr [x],edx		存在对同一数据的读写， 乱序会造成数据异常需要
x %= 10mov         eax,dword ptr [x]  
cdq  
mov         ecx,0Ah  
idiv        eax,ecx  
mov         dword ptr [x],edx		存在对同一数据的读写， 乱序会造成数据异常需要
x >> ymov         eax,dword ptr [x]  
mov         ecx,dword ptr [y]  
sar         eax,cl		不赋值给其他变量是没有意义的，不做讨论 
x >> 1mov         eax,dword ptr [x]  
sar         eax,1		不赋值给其他变量是没有意义的，不做讨论 
x << ymov         eax,dword ptr [x]  
mov         ecx,dword ptr [y]  
shl         eax,cl		不赋值给其他变量是没有意义的，不做讨论 
x << 1mov         eax,dword ptr [x]  
shl         eax,1		不赋值给其他变量是没有意义的，不做讨论 
x >>= ymov         eax,dword ptr [x]  
mov         ecx,dword ptr [y]  
sar         eax,cl  
mov         dword ptr [x],eax		存在对同一数据的读写， 乱序会造成数据异常需要
x >>= 1mov         eax,dword ptr [x]  
sar         eax,1  
mov         dword ptr [x],eax		存在对同一数据的读写， 乱序会造成数据异常需要
x <<= ymov         eax,dword ptr [x]  
mov         ecx,dword ptr [y]  
shl         eax,cl  
mov         dword ptr [x],eax		存在对同一数据的读写， 乱序会造成数据异常需要
x <<= 1mov         eax,dword ptr [x]  
shl         eax,1  
mov         dword ptr [x],eax		存在对同一数据的读写， 乱序会造成数据异常需要
x & ymov         eax,dword ptr [x]  
and         eax,dword ptr [y]		不赋值给其他变量是没有意义的，不做讨论 
x & 10mov         eax,dword ptr [x]  
and         eax,0Ah		不赋值给其他变量是没有意义的，不做讨论 
x &= ymov         eax,dword ptr [x]  
and         eax,dword ptr [y]  
mov         dword ptr [x],eax		存在对同一数据的读写， 乱序会造成数据异常需要
x &= 10mov         eax,dword ptr [x]  
and         eax,0Ah  
mov         dword ptr [x],eax		存在对同一数据的读写， 乱序会造成数据异常需要
x | ymov         eax,dword ptr [x]  
or          eax,dword ptr [y] 		不赋值给其他变量是没有意义的，不做讨论 
x | 10mov         eax,dword ptr [x]  
or          eax,0Ah		不赋值给其他变量是没有意义的，不做讨论 
x |= ymov         eax,dword ptr [x]  
or          eax,dword ptr [y]  
mov         dword ptr [x],eax		存在对同一数据的读写， 乱序会造成数据异常需要
x |= 10mov         eax,dword ptr [x]  
or          eax,0Ah  
mov         dword ptr [x],eax		存在对同一数据的读写， 乱序会造成数据异常需要
x ^ ymov         eax,dword ptr [x]  
xor         eax,dword ptr [y] 		不赋值给其他变量是没有意义的，不做讨论 
x ^ 10mov         eax,dword ptr [x]  
xor         eax,0Ah		不赋值给其他变量是没有意义的，不做讨论 
x ^= ymov         eax,dword ptr [x]  
xor         eax,dword ptr [y]  
mov         dword ptr [x],eax		存在对同一数据的读写， 乱序会造成数据异常需要
x ^= 10mov         eax,dword ptr [x]  
xor         eax,0Ah  
mov         dword ptr [x],eax		存在对同一数据的读写， 乱序会造成数据异常需要
!xxor         eax,eax  
cmp         dword ptr [x],0  
sete        al		不赋值给其他变量是没有意义的，不做讨论 
~xmov         eax,dword ptr [x]  
not         eax		不赋值给其他变量是没有意义的，不做讨论 

对内建类型变量的赋值(数值):

类型反汇编代码（vs2010）说明                             
同步？        
char x = 10;mov         byte ptr [x],0Ah原子操作不需要
unsigned char x = 10;mov         byte ptr [x],0Ah原子操作不需要
short x = 10;mov         eax,0Ah  
mov         word ptr [x],ax		只有一个写操作不需要
unsigned short x = 10;mov         eax,0Ah  
mov         word ptr [x],ax		只有一个写操作不需要
int x = 10;mov         dword ptr [x],0Ah原子操作不需要
unsigned int x = 10;mov         dword ptr [x],0Ah原子操作不需要
long x = 10;mov         dword ptr [x],0Ah原子操作不需要
unsigned long x = 10;mov         dword ptr [x],0Ah原子操作不需要
long long x = 0xFFFFFFFFFFFF;mov         dword ptr [x],0FFFFFFFFh  
mov         dword ptr [ebp-8],0FFFFh		写写操作需要
unsigned long long x = 0xFFFFFFFFFFFF;mov         dword ptr [x],0FFFFFFFFh  
mov         dword ptr [ebp-8],0FFFFh		写写操作需要
float x = 10.20;fld         dword ptr [__real@41233333 (0F6311Ch)]  
fstp        dword ptr [x]		只有一个写操作不需要
double x = 10.20;fld         qword ptr [__real@4024666666666666 (13D3120h)]  
fstp        qword ptr [x]		只有一个写操作不需要
__int8 x = 10;
mov         byte ptr [x],0Ah
原子操作不需要
__int16 x = 10;
mov         eax,0Ah  
mov         word ptr [x],ax
只有一个写操作不需要
__int32 x = 10;
mov         dword ptr [x],0Ah  
原子操作不需要
__int64 x = 0xFFFFFFFFFFFF;
mov         dword ptr [x],0FFFFFFFFh  
mov         dword ptr [ebp-8],0FFFFh
写写操作需要

对内建类型变量的赋值（变量）:

类型反汇编代码（vs2010）说明                             
同步？        
char x = y;mov         al,byte ptr [y]  
mov         byte ptr [x],al		非对同一数据的读写，而且乱序不会对数据结果产生影响不需要
unsigned char x = y;mov         al,byte ptr [y]  
mov         byte ptr [x],al		非对同一数据的读写，而且乱序不会对数据结果产生影响不需要
short x = y;mov         ax,word ptr [y]  
mov         word ptr [x],ax		非对同一数据的读写，而且乱序不会对数据结果产生影响不需要
unsigned short x = y;mov         ax,word ptr [y]  
mov         word ptr [x],a		非对同一数据的读写，而且乱序不会对数据结果产生影响不需要
int x = y;mov         eax,dword ptr [y]  
mov         dword ptr [x],eax		非对同一数据的读写，而且乱序不会对数据结果产生影响不需要
unsigned int x = y;mov         eax,dword ptr [y]  
mov         dword ptr [x],eax		非对同一数据的读写，而且乱序不会对数据结果产生影响不需要
long x = y;mov         eax,dword ptr [y]  
mov         dword ptr [x],eax		非对同一数据的读写，而且乱序不会对数据结果产生影响不需要
unsigned long x = y;mov         eax,dword ptr [y]  
mov         dword ptr [x],eax		非对同一数据的读写，而且乱序不会对数据结果产生影响不需要
long long x = y;mov         eax,dword ptr [y]  
mov         dword ptr [x],eax  
mov         ecx,dword ptr [ebp-18h]  
mov         dword ptr [ebp-8],ecx		对x存在写写操作，乱序会产出数据”撕裂“需要
unsigned long long x = y;mov         eax,dword ptr [y]  
mov         dword ptr [x],eax  
mov         ecx,dword ptr [ebp-18h]  
mov         dword ptr [ebp-8],ecx		对x存在写写操作，乱序会产出数据”撕裂“需要
float x = y;fld         dword ptr [y]  
fstp        dword ptr [x]		非对同一数据的读写，而且乱序不会对数据结果产生影响不需要
double x = y;fld         qword ptr [y]  
fstp        qword ptr [x]		非对同一数据的读写，而且乱序不会对数据结果产生影响不需要
__int8 x = y;
mov         al,byte ptr [y]  
mov         byte ptr [x],al
非对同一数据的读写，而且乱序不会对数据结果产生影响不需要
__int16 x =y;
mov         ax,word ptr [y]  
mov         word ptr [x],ax
非对同一数据的读写，而且乱序不会对数据结果产生影响不需要
__int32 x =y;
mov         eax,dword ptr [y]  
mov         dword ptr [x],eax
非对同一数据的读写，而且乱序不会对数据结果产生影响不需要
__int64 x = y;
mov         eax,dword ptr [y]  
mov         dword ptr [x],eax  
mov         ecx,dword ptr [ebp-18h]  
mov         dword ptr [ebp-8],ecx
 需要
aisq
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 原子操作与无锁编程
c553110519的专栏
08-17 2667
c++ 原子操作， 无锁编程原理
【C++11】原子操作（atomic operation）
K2016_04_16的博客
01-08 166
​ 所谓的原子操作，取的就是“原子是最小的、不可分割的最小个体”的意义，它表示在多个线程访问同一个全局资源的时候，能够确保所有其他的线程都不在同一时间内访问相同的资源。也就是他确保了在同一时刻只有唯一的线程对这个资源进行访问。这有点类似互斥对象对共享资源的访问的保护，但是原子操作更加接近底层，因而效率更高。
原子操作及其重要性
xueyingxue001的专栏
09-17 1223
何为“原子操作”呢？     其实说白了，就是一个由多步操作组成，这些步骤要不执行就一个都不执行，如果执行的话，那么从第一步开始到最后一步结束绝对不会被信号等线程调度机制打断。    《APUE》上说的“原子的执行”也就是这个意思了。 其重要性在哪呢？     我们知道，CPU在用极快的速度不停地切换运行程序，这样的好处是可以“同时”运行好多程序，但坏处就是可能会造成一些让我们头痛不已的问
深入理解Volatile，synchronized，原子操作的必要性
江南的博客
03-04 502
1多线程问题1.1为什么要使用Volatile？ 1.2:竞态条件触发？ 1.3:内存可见性？］ 1.4多线程中堆，栈的分布 2:java中的内存分配 3:一个锁引发的问题 多线程问题为什么要使用Volatile？为什么要使用Volatile？搞清楚这个问题先看一个情形。如果线程 A 对对象中的某个变量进行修改后还没来得及写回主存，线程 B 也对该变量进行了修改，那最后刷新回主内存后的值一定和期望的
C++11并发编程关于原子操作atomic的代码示例
12-25
C++11提供了个原子的类和方法atomic，保证了多线程对变量原子性操作，相比加锁机制mutex.lock()，mutex.unlock()，性能有几倍的提升。 所需头文件 二：错误代码 //全局变量 int g_num = 0; void fun() {
C++编程规范 Google 中文版 C++编程规范 自建笔记
05-29
《C++编程规范》是Google公司为C++程序员制定的一套详细且严谨的编码标准，旨在提高代码质量、可读性、可维护性和团队协作效率。这份中文版结合了Google的实践经验，为开发者提供了丰富的编程指导，是每一位C++...
windows c++ 原子操作例子
02-01
在Windows平台上，C++编程中使用原子操作(Atomic Operations)是为了保证多线程环境下的数据一致性，避免竞态条件和死锁等问题。原子操作是指在多线程环境下，该操作会被完整无中断地执行，不会被其他线程打断。...
C++ GPU编程(英伟达CUDA)
最新发布
06-21
4. **并行编程概念**：CUDA编程涉及多线程并行执行，理解线程同步、原子操作和内存一致性模型是关键。例如，`cudaThreadSynchronize()`用于确保所有线程块完成执行，`atomic`函数用于在多线程环境中安全地更新共享...
原子操作的简单介绍
m0_72167535的博客
03-19 279
CAS操作需要输入两个数值，一个旧值(期望操作 前的值),一个新值，在操作期间先比较旧值有没有发生变化，如果没有发生变化才交换成新值，发生了变化则不交换。替换原来的值，只是改变了atomicReference对象的值，user1的值不会改变。处理器通过总线锁和缓存锁保证基本内存操作的原子性。原子操作是指不会被线程调度机制打断的操作。可以避免多线程操作共享资源出现的问题。场景：对少量资源进行数据更新操作。例如，对单个变量进行操作的场合。get()：获取当前的值。CPU指令级别提供支持。
详解C++11原子类型与原子操作
12-17
1.认识原子操作 原子操作就是在多线程程序中“最小的且不可并行化的”操作，意味着多个线程访问同一个资源时，有且仅有一个线程能对资源进行操作。通常情况下原子操作可以通过互斥的访问方式来保证，例如Linux下的互斥锁（mutex），Windows下的临界区（Critical Section）等。下面看一个Linux环境使用POSIX标准的pthread库实现多线程下的原子操作： #include #include using namespace std; int64_t total=0; pthread_mutex_t m=PTHREAD_MUTEX
我所理解liunx下的原子操作
weixin_42432281的博客
08-05 424
原子操作就是要么不执行，一旦执行就会执行完成，是不可被打断的一个，或一系列的动作，即在完成任务前不会被其他事件所打断，就像原子不可被分割成颗粒一样。单处理中，可以用单条指令完成的指令可以被看成是一个原子操作。软件中的原子操作依赖于硬件原子操作的支持。当然原子操作，也可以当引用计数使用。......
C++11原子操作性能测试
weixin_30924087的博客
12-17 253
测试结论是发现C++11原子操作在性能上，比以往用到的InterlockedIncrement或__sync_add_and_fetch性能上慢了1倍左右。 另外补充一点，在对原子变量进行比较的时候，最好是引用它操作后的返回值，而不要直接用原子变量进行比较，比如： 下面是测试过程以及代码 std::atomic<long> g_data = 0; long v = ++g_...
C++11之原子操作原理与使用(一百二十)
Android系统攻城狮
06-07 4586
【1】单个CPU的情况【1】有两个线程，线程thread1对变量aa读操作，线程thread2对变量中写值。 【2】在线程thread1里，对aa读操作，放入tmp变量中，以后使用 【3】在线程thread2里，对aa写操作 结果：原本是想读出来aa = 5的值，结果可能读出来是已经修改的值100，不是自己想要的脏数据，所以对变量读写要保持其原子性----->即：执行中不可被打断。原子操作： 可以把原子操作理解为：不需要用到互斥量加锁（无锁）技术的多线程编程方式，多线程中不会被打断的程序执行片段
5.9 汇编语言：浮点数操作指令
CSDN
08-23 8170
浮点运算单元是从80486处理器开始才被集成到CPU中的，该运算单元被称为FPU浮点运算模块，FPU不使用CPU中的通用寄存器，其有自己的一套寄存器，被称为浮点数寄存器栈，FPU将浮点数从内存中加载到寄存器栈中，完成计算后在回写到内存中。 FPU有8个可独立寻址的80位寄存器，分别名为`R0-R7`他们以堆栈的形式组织在一起，栈顶由FPU状态字中的一个名为TOP的域组成，对寄存器的引用都是相对于栈顶而言的，栈顶通常也被叫做ST(0)最后一个栈底则被记作ST(7)其使用方式与堆栈一致。
Linux内核原语（三）——原子操作
Hello Mr.Z的博客
05-17 561
Linux内核原语（二）——原子操作 小狼@http://blog.csdn.net/xiaolangyangyang 原子操作，指的是一段不可打断的执行。也就是你不可分割的操作。 在 Linux 上提供了原子操作的结构，atomic_t ： typedef struct { int counter; } atomic_t; 把整型原子操作定义为结构体，让原子函数只接收atomic_t类型的参数进而确保原子操作只与这种特殊类型数据一起使用，同时也保证了该类型的数...
VC8常用代码对应汇编 成员变量赋值
闻缺陷则喜何志丹
10-13 527
操作系统Win7 32位 1,int成员变量赋值 class CTest { public:  CTest(void); public:   int m_x ;  int m_y; }; m_x = 1;对应的汇编  mov  DWORD PTR [eax], 1 m_y = 3;对应的汇编  mov  DWORD PTR [eax+4], 3 2,short成员变量赋
在C/C++代码中使用SSE等指令集的指令(1)介绍
热门推荐
。。。。
11-24 2万+
我们知道，在C/C++代码中，可以插入汇编代码提高性能。现在的指令集有了很多的高级指令，如果我们希望使用这些高级指令来实现一些高效的算法，就可以在代码中嵌入汇编，使用SSE等高级指令，这是可行的，但是如果对汇编不太熟悉，不愿意使用汇编的人来说，其实也是可以的，这就是Compiler Intrinsics（http://msdn.microsoft.com/zh-cn/site/26td21ds）。
c语言只中原子变量含义,c语言中的原子操作 - osc_bkg5rgl1的个人空间 - OSCHINA - 中文开源技术交流社区...
weixin_35250656的博客
05-18 1392
1. 原子操作：原子操作指的是在执行过程中不会被别的代码所中断的操作.。分为 位 和 整型变量 两类原子操作。typedef struct { volatile int counter; } atomic_t;2. 原子操作函数 分为 整形原子操作 和 位原子操作3. 整型原子操作：void atomic_set(atomic_t *v, int i); //设置原子变量v的值为iatomic_t...
OpenMP原子操作：共享内存编程的关键
在这样的系统中，原子操作可以防止数据竞争（多个线程同时修改同一数据导致的结果不确定），确保每个操作的执行顺序对其他线程是可见的。 原子操作通常涉及读取、修改和写回操作，它们在执行过程中不会被其他线程...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值