C语言/原子/编译，你真的明白了吗？

　　版权申明：本文为博主窗户(Colin Cai)原创，欢迎转帖。如要转贴，必须注明原文网址

　　http://www.cnblogs.com/Colin-Cai/p/7668982.html 

　　作者：窗户

　　QQ：6679072

　　E-mail：6679072@qq.com

　　说到原子，类似于以下的代码可能人人都可以看出猫腻。

/* http://www.cnblogs.com/Colin-Cai */
#include <stdio.h>
#include <pthread.h>

int cnt = 0;
void* mythread(void* arg)
{
        int i;
        for(i=0;i<500000000;i++)
                cnt++;
        return NULL;
}

int main()
{
        pthread_t id, id2;

        pthread_create(&id, NULL, mythread, NULL);
        pthread_create(&id2, NULL, mythread, NULL);
        pthread_join(id, NULL);
        pthread_join(id2, NULL);
        printf("cnt = %dn", cnt);

        return 0;
}

　　我想大多数人都知道其结果未必会得到1000000000。

　　测试一下吧。

linux-p94b:/tmp/testhere # gcc test1.c -lpthread
linux-p94b:/tmp/testhere # for((i=0;i<10;i++));do ./a.out ; done
cnt = 1000000000
cnt = 1000000000
cnt = 1000000000
cnt = 1000000000
cnt = 1000000000
cnt = 1000000000
cnt = 958925625
cnt = 1000000000
cnt = 1000000000
cnt = 1000000000

　　可是真的知道猫腻了吗？如果我编译的时候优化一下呢？

linux-p94b:/tmp/testhere # gcc -O2 test1.c -lpthread
linux-p94b:/tmp/testhere # for((i=0;i<10;i++));do ./a.out ; done
cnt = 1000000000
cnt = 1000000000
cnt = 1000000000
cnt = 1000000000
cnt = 1000000000
cnt = 1000000000
cnt = 1000000000
cnt = 1000000000
cnt = 1000000000
cnt = 1000000000

　　运行速度一下子变的飞快，而且似乎都得到了10亿。

　　这里，mythread里cnt自加5亿次被优化成了 cnt += 500000000

　　那么当然快啊，可是似乎这与我们当初想测试原子有那么一些差异，一样的代码，不一样的编译，却带来了不同的结果。

　　其实原因在于，我们这里代码写的不好，才没有表达好我们当初的意思，我们是希望cnt真的自加5亿次。那么怎么办呢？其实很好办，在cnt的定义前面加个volatile，那么这里对于cnt的自加则不会优化。很多时候，为什么我们优化前和优化后的结果不一样，常常是因为写代码的人不明白程序的优化规则。在上个公司的时候，我很想临走的时候再给大家做一个培训，说说C语言的优化，同时说说我们平时写的无意依赖于编译的所谓垃圾代码，但是直到离开，我还是没有做此培训。

　　我们加了volatile试一下，

linux-p94b:/tmp/testhere # gcc -O2 test1.c -lpthread
linux-p94b:/tmp/testhere # for((i=0;i<10;i++));do ./a.out ; done
cnt = 635981117
cnt = 675792826
cnt = 522700646
cnt = 593410055
cnt = 544306380
cnt = 630888304
cnt = 580539893
cnt = 629360072
cnt = 555570127

　　我们在cnt定义前加个volatile，效果果然就更明显了，因为真的是自加5亿次，导致问题的机会变多了。那么之前没加volatile并优化编译，会不会也有不得到10亿的可能呢？

　　我们首先要明白的是，这里的cnt++不是原子操作，中间有随时调度的可能。

　　5亿次太多，我们就拿只自加1次为例即可说明，两个线程都只自加1次，本来期待结果为2.

　　cnt++在一般的处理器中至少有三条指令，我们用伪汇编来写。　　

　　cnt -> reg　　//把cnt从内存加载到寄存器reg

　　reg+1 -> reg //寄存器reg自加1

　　reg -> cnt     //把reg的内容写入内存

　　那么，

       (线程1)cnt -> reg

　　(线程1)reg+1 -> reg

　　(线程1)reg -> cnt

       (线程2)cnt -> reg

　　(线程2)reg+1 -> reg

　　(线程2)reg -> cnt

　　理想中，我们认为处理器的执行是以上这样，结果cnt里的值是2。

　　但假设过程中发生了调度，指令执行的顺序并非像以上这样，假如变成了以下这样

       (线程1)cnt -> reg

　　(线程1)reg+1 -> reg　　

       (线程2)cnt -> reg

　　(线程2)reg+1 -> reg

　　(线程2)reg -> cnt

　　(线程1)reg -> cnt 

　　我们再来算算，

　　cnt = 0,  reg任意

       (线程1)cnt -> reg

　　cnt = 0, reg =  0

　　(线程1)reg+1 -> reg

　　cnt = 0, reg = 1

　　此处调度，reg = 1会被保存，并在重新调度回来之后有效,而cnt不会管

　　调度之后

　　cnt = 0, reg任意　

       (线程2)cnt -> reg

　　cnt = 0, reg = 0

　　(线程2)reg+1 -> reg

　　cnt = 0, reg = 1

　　(线程2)reg -> cnt

　　cnt = 1, reg = 1

　　此处又发生调度，reg会恢复之前保存的1，而cnt不会有任何变化

　　所以在执行下一条指令前，

　　cnt = 1, reg = 1

　　(线程1)reg -> cnt 

　　cnt = 1, reg = 1

　　我们可以看到，结果成了1，而不是2，这就是非原子操作导致的结果，其实之前优化成cnt += 500000000本身也依然有此问题，只是难以观察的到。

　　虽然x++不是原子，但是我们可以使用锁的方式，来人为的制造“原子”，比如这里用互斥。

#include <stdio.h>
#include <pthread.h>

volatile int cnt = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* mythread(void* arg)
{
        int i;
        for(i=0;i<500000000;i++) {
                pthread_mutex_lock(&mutex);
                cnt++;
                pthread_mutex_unlock(&mutex);
        }
        return NULL;
}

int main()
{
        pthread_t id, id2;

        pthread_create(&id, NULL, mythread, NULL);
        pthread_create(&id2, NULL, mythread, NULL);
        pthread_join(id, NULL);
        pthread_join(id2, NULL);
        printf("cnt = %dn", cnt);

        return 0;
}

　　测试一下

linux-p94b:/tmp/testhere # gcc -O2 test1.c -lpthread
linux-p94b:/tmp/testhere # for((i=0;i<10;i++));do ./a.out ; done
cnt = 1000000000
cnt = 1000000000
cnt = 1000000000
cnt = 1000000000
cnt = 1000000000
cnt = 1000000000
cnt = 1000000000
cnt = 1000000000
cnt = 1000000000
cnt = 1000000000