C开发 中原子性操作 , 除了快什么都不剩下了

题外话

　　今天,听歌曲听到一首缅怀迈克尔·杰克逊的歌曲 如下:

 http://music.163.com/#/song?id=1696048  Breaking News

每次听迈克尔 音乐,特别有战斗力,特别兴奋,学起技术来也特别带感,推荐喜欢的人试试.

#include <stdio.h>

int man(int argc, char* argv[])
{
   printf("Hope you are better %s
","Michael Jackson"); 
   return 0;  
}

前言

今天要说的是

1. 通过实际例子开头 说明 互斥量, 原子操作, 原子互斥锁 性能对比

2. 简单 说一下Linux 同样的性能对比

3. 构建一个跨平台的简单原子操作框架

4. Window 和 Linux 都简单测试一下

预备知识  

1.线程的使用 最好是 posix线程库

2.简单C基础(说个 题外话,将C之父 那本书来回看个3遍,多写几遍,基本就是一个合格C程序员了)

参照资料

1. gcc 原子操作帮助文档 https://gcc.gnu.org/onlinedocs/gcc-4.1.1/gcc/Atomic-Builtins.html

2. Window 提供的原子操作API https://msdn.microsoft.com/en-us/library/windows/desktop/ms686360(v=vs.85).aspx#interlocked_functions

正文

  首先我们直奔 任务1, 通过实际例子开头 说明 互斥量, 原子操作, 原子互斥锁 性能对比

1.0 pthread 预备

　　需要会使用pthread 线程库,特别是在Window上, 在 Linux 默认就是posix 线程库,只需要在gcc 后面 加上 -lpthread 例如如下

gcc -Wall -o atom.out atom.c sc_atom.h -lpthread

没使用的可以 参照 我的其它博文,好像是一个介绍 printf 函数一个博文中简单讲解了,怎么 在Window上使用 pthread的全过程.

这里 再 简单说一下,为什么 要在 Window上折腾,是这样的 毕竟 是从开机 -> 走上程序开发道路 , 那时候 上大一,第一次了解Window其实个操作系统.

以前心里默认以为 window 就是 电脑,电脑就是window 二者是一个对映关系. 后来常在 Linux工作,开发学习. 还是觉得 Window有很多优点,是不错的操作系统.

其实 再闲扯一点(个人比较菜 望见谅)

Window 挺难的,源码 看得好恶心 工资低

Linux 简单,源码容易看,工资高一点

这 业界 喜好 就出来了.简单回报高,谁不喜欢.

1.1 简单看代码

  这里先看下面代码 ,第一段 普通 pthread_mutex 互斥量

//测试 pthread 互斥量
void* test_one(void* arg);

#define _INT_CUTS (2000000)

//测试 的全局区变量,默认值为0
static int __cut;
//全局的锁变量
static pthread_mutex_t __mx = PTHREAD_MUTEX_INITIALIZER;

void* 
test_one(void* arg)
{
    for (int i = 0; i < _INT_CUTS; ++i) {
        pthread_mutex_lock(&__mx);
        ++__cut;
        pthread_mutex_unlock(&__mx);
    }

    return NULL;
}

上面代码 特别标准,一般多线程程序代码,基本就是上面结构,扯一点 对于下面多线程函数

PTW32_DLLPORT int PTW32_CDECL pthread_mutex_destroy (pthread_mutex_t * mutex);

只有 在 通过

PTW32_DLLPORT int PTW32_CDECL pthread_mutex_init (pthread_mutex_t * mutex,
                                const pthread_mutexattr_t * attr);

初始化的互斥量,才需要调用,对于直接 通过 初始化值初始化的互斥量就不需要调用了.

现在介绍 一个 原子操作的版本,先看Windows 的

//测试 原子操作
void* test_two(void* arg);

#define _INT_CUTS (2000000)

//测试 的全局区变量,默认值为0
static int __cut;

//测试 原子操作
void* 
test_two(void* arg)
{
    for (int i = 0; i < _INT_CUTS; ++i) {
        InterlockedExchangeAdd(&__cut, 1);
    }

    return NULL;
}

这里函数 InterlockedExchangeAdd 是 Window.h 中提供的 具体的意思 如下

#define InterlockedExchangeAdd _InterlockedExchangeAdd

/*
 *  原子操作,绑定在一起 完成 第一个数 = 第一个数+被加数 ,并返回开始加的时候第一个数
 * Addend : 加数的地址
 * Value : 被加数
 */
LONG
__cdecl
InterlockedExchangeAdd (
    _Inout_ _Interlocked_operand_ LONG volatile *Addend,
    _In_ LONG Value
    );

可以理解为,下面一起执行的操作命令集

tmp = old ; old = old + value ; return tmp ;

最后介绍一个 利用原子操作 实现的互斥锁

//测试 原子锁操作
void* test_three(void* arg);

#define _INT_CUTS (2000000)

//测试 的全局区变量,默认值为0
static int __cut;

//全局 锁
static int __lk;

//测试 原子锁操作
void* 
test_three(void* arg)
{
    for (int i = 0; i < _INT_CUTS; ++i) {

        while (InterlockedExchange(&__lk, 1)) {
            Sleep(0);
        }

        ++__cut;

        InterlockedExchange(&__lk, 0);
    }

    return NULL;
}

这里同样简单 解释一下

#define InterlockedExchange _InterlockedExchange

/*
 * 这个函数作用是 交换 *Target 和 Value 值,并返回老的值
 *  
 * Target : 目标值得地址
 * Value : 待交换的值
 *
 * return : 交换之前的 *Target 值
 */
LONG
__cdecl
InterlockedExchange (
    _Inout_ _Interlocked_operand_ LONG volatile *Target,
    _In_ LONG Value
    );

上面函数 等价于 下面指令集一起执行.

tmp = *Target ; *Target = Value ; Value = tmp ; return tmp ;

对于

        while (InterlockedExchange(&__lk, 1)) {
            Sleep(0);
        }

相当加锁 , 例如当 __lk 为 0 的时候,先进入的线程 设置为1,返回0它进入了,别的线程来了,返回的值可能是1,那么 就执行

Sleep(0),等待.假如你要是写成下面这样

while (InterlockedExchange(&__lk, 1)) { }

就是 出名的 "忙等待 ",语言层等待函数, 测试结果是程序 基本上卡死. 这就 人一样,需要 休息 一下,才更有精力和动力 去做其它的事. 老是 加班效果不好. 但 没办法 , 因为自己只是个打工仔,,,,,

后面使用

InterlockedExchange(&__lk, 0);

将这个变量设置为 0 ,那么 另一个线程 执行 set 1时候,返回 0 while 退出,获得线程资源,就这样 循环起来了,是不是 恍然大悟!!!

上面三种实现 多线程竞争的访问资源的方式 ,都比较安全, 我们具体的看一下 测试结果 采用 Window 10 x64 + VS 2015 + Release + x86 模式 测试 截图如下:

是不是很惊讶, 原子操作快 我也不说了,居然 原子互斥锁更快,但事实就是这样, 这里 可以更快一点 优化点在 Sleep(0), 这个函数 参数 以微秒记录. 更加优化,不同操作

系统,这个最优值不一样.这里 我就设了一个 性能可以的值. 大家可以尝试一下.

扯一点 在 Linux 中 有个函数 usleep 函数,在Window 上没有,但是也可以实现, 参照资料 如下

http://stackoverflow.com/questions/5801813/c-usleep-is-obsolete-workarounds-for-windows-mingw

觉得 Linux 的API 和 Window API 都各有所长,各有所短,综合而言还是 Linux API人性化一点,能够优化的东西更多.

完整的测试代码 如下

#include "pthread.h"
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
#include <time.h>

//1.0 简单的time帮助宏
#ifndef TIME_PRINT
#define TIME_PRINT(code) {
    clock_t __st,__et;
    __st=clock();
    code
    __et=clock();
    printf("当前代码块运行时间是:%lf秒
",(0.0+__et-__st)/CLOCKS_PER_SEC);
}
#endif /*!TIME_PRINT*/

//测试 pthread 互斥量
void* test_one(void* arg);
//测试 原子操作
void* test_two(void* arg);
//测试 原子锁操作
void* test_three(void* arg);

#define _INT_TIDS (50)
#define _INT_CUTS (2000000)

//测试 的全局区变量,默认值为0
static int __cut;
//全局的锁变量
static pthread_mutex_t __mx = PTHREAD_MUTEX_INITIALIZER;
//全局 锁
static int __lk;

static void __test_func(void* (*func)(void *))
{
    pthread_t tids[_INT_TIDS];
    int i;

    for (i = 0; i < _INT_TIDS; ++i) {
        pthread_create(tids + i, NULL, func, NULL);
    }

    //等待结束
    for (i = 0; i < _INT_TIDS; ++i)
        pthread_join(tids[i], NULL);
}

int main(int argc, char *argv[])
{
    printf("__cut = %d, __mx = %d, __lk = %d
", __cut, (int)__mx, __lk);

    // 只为简单测试,没有做安全检查,假定都会调用成功

    puts("
线程互斥锁数据如下:");
    __cut = 0;
    TIME_PRINT({
        __test_func(test_one);
    });
    printf("__cut = %d, __mx = %d, __lk = %d
", __cut, (int)__mx, __lk);


    puts("
原子操作数据如下:");
    __cut = 0;
    TIME_PRINT({
        __test_func(test_two);
    });
    printf("__cut = %d, __mx = %d, __lk = %d
", __cut, (int)__mx, __lk);


    puts("
原子锁操作数据如下:");
    __cut = 0;
    TIME_PRINT({
        __test_func(test_three);
    });
    printf("__cut = %d, __mx = %d, __lk = %d
", __cut, (int)__mx, __lk);

    system("pause");
    return 0;
}

void* 
test_one(void* arg)
{
    for (int i = 0; i < _INT_CUTS; ++i) {
        pthread_mutex_lock(&__mx);
        ++__cut;
        pthread_mutex_unlock(&__mx);
    }

    return NULL;
}

//测试 原子操作
void* 
test_two(void* arg)
{
    for (int i = 0; i < _INT_CUTS; ++i) {
        InterlockedExchangeAdd(&__cut, 1);
    }

    return NULL;
}

//测试 原子锁操作
void* 
test_three(void* arg)
{
    for (int i = 0; i < _INT_CUTS; ++i) {

        while (InterlockedExchange(&__lk, 1)) {
            Sleep(0);
        }

        ++__cut;

        InterlockedExchange(&__lk, 0);
    }

    return NULL;
}

到这里 , 第一目标就告一段落,再扯一点,提升编程最好 手段 就是 临摹,如果人不聪明的话 多敲键盘.

2. 简单 说一下Linux 同样的性能对比

2.1 直接上代码

测试 代码 gcc_sync.c , 采用Ubuntu 15.10 操作系统,感觉挺好用的,比Centos 好用,好开发.大家试试

(这里,写的比较简单随意,我是先在Linux上测试的,测试之后再在Window上按照同样的设计思路写代码,开发中遇到比较难得问题,都是先用C写一遍稳固设计思路,再转成其它语言.)

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <time.h>
#include <unistd.h>

static int __cut = 0;

void* test_func(void* arg);

#define _INT_THREAD (30)

static pthread_mutex_t __mx = PTHREAD_MUTEX_INITIALIZER;
static int __lk = 0;

int main(int argc,char* argv[])
{
        pthread_t tid[_INT_THREAD];
        int i;

        printf("__cut = %d
",__cut);

        clock_t st = clock();
        for(i=0; i<20; ++i)
                pthread_create(tid + i, NULL, test_func, NULL);

        for(i=0; i<20; ++i)
                pthread_join(tid[i], NULL);
        clock_t et = clock();

        printf("__cut = %d
",__cut);
        printf("经历了 %lf 秒
",(et-st)*1.0/CLOCKS_PER_SEC);

        return 0;
}

// 简单的测试 自增N次
void*
test_func(void* arg)
{
        int i = 0;
        while(i++<2000000){
                //pthread_mutex_lock(&__mx);

                //__sync_fetch_and_add(&__cut,1);


                while(__sync_lock_test_and_set(&__lk,1)) {
                        usleep(0);
                }

                ++__cut;

                __sync_lock_release(&__lk);

                //pthread_mutex_unlock(&__mx);
        }
        return NULL;
}

编译命令是

gcc -g -Wall -o gcc_sync.out gcc_sync.c -lpthread

测试结果 也 同样 ,所用时间  pthread_mutex > 原子加 > 原子互斥量

对于 上面代码 简单说一下

__sync_fetch_and_add(&__cut,1);

意思是 为__cut增加 1,并返回 原先的__cut值.

更加详细的关于 gcc 提供的原子操作,可以看 前言 中 参照资料的第一个.其实 gcc 提供的原子操作 "函数",真的 是魔法函数,是编译器层的不是语言层的.

Windows 上的 InterlockedExchangeAdd 还是 语言层的,有固定的返回类型.

对于下面函数,详细说一下

                while(__sync_lock_test_and_set(&__lk,1)) {
                        usleep(0);
                }

对于

/*
 * 原子操作,交换 *ptr 和 value ,并且返回交换后的 value值 
 *
 * type : 可以是1,2,4或8字节长度的int类型 , int8_t/uint64_t 都可以...
 * value : 目标 *ptr 交换的值
 * ... : 后面的可扩展参数(...)用来指出哪些变量需要memory barrier,因为目前gcc实现的是full barrier,这个意思表示 这个函数之前的内存变量操作指令不会出现在这个函数之后执行.
 * 
 * return : *ptr 之前的值就是 交换后的value
 */
type __sync_lock_test_and_set (type *ptr, type value, ...)

等同于

tmp = value ; value = *ptr ; *ptr = tmp ; return value ;

对于 usleep(0), 这个自己也在测试 目前 测了一下 感觉 usleep(2) 效果比较好, 和操作系统和 硬件和 代码复杂度 关系大, 自己 目前就用 usleep(2); 这是个优化点.

最后一个是

void __sync_lock_release (type *ptr, ...)This builtin releases the lock acquired by __sync_lock_test_and_set. Normally this means writing the constant 0 to *ptr. 

将值设为0,和 __sync_lock_test_and_set 配套使用

等价于 下面原子操作

*ptr = 0

到这里 大概 原子操作的概念就建立起来,至少知道 原子操作怎么搞了.

3. 构建一个跨平台的简单原子操作框架

这里 同样直接上代码 ,再挨个解释. 代码总感觉有点难看, 但不知道怎么改,下次再优化

文件名 sc_atom.h

#ifndef _H_SC_ATOM
#define _H_SC_ATOM

/*
 * 这段关于原子操作的宏 主要在 VS 和 GCC 中跑
 * 
 * 为什么要用原子操作,因为它快,很快. 接近硬件层,怎么使用会做具体的注释
 */

#if defined(_MSC_VER)
//这里主要 _WIN32 操作 ,对于WIN64 没有做了,本质一样,函数后面加上64. 这里定位就是从简单的跨平台来来    
#include <Windows.h>

//全部采用后置原子操作,先返回old的值 (前置等价 => tmp = v ; v = v + a ; return tmp)
#define SC_ATOM_ADD(v,a) 
    InterlockedAdd(&(v),(a))

//将a的值设置给v,返回设置之前的值
#define SC_ATOM_SET(v,a) 
    InterlockedExchange(&(v),(a))

// v == c ? swap(v,a) ; return true : return false.
#define SC_ATOM_COM(v,c,a) 
    ( c == InterlockedCompareExchange(&(v), (a), c))

//第一次使用 v最好是 0
#define SC_ATOM_LOCK(v) 
    while(SC_ATOM_SET(v,1)) { 
        Sleep(0); 
    }

#define SC_ATOM_UNLOCK(v) 
    SC_ATOM_SET(v,0)

#elif defined(__GNUC__)
#include <unistd.h>    

 //全部采用后置原子操作,先返回old的值 (前置等价 => a = i++)
#define SC_ATOM_ADD(v,a) 
    __sync_fetch_and_add(&(v),(a))

 //将a的值设置给v,返回设置之前的值
#define SC_ATOM_SET(v,a) 
    __sync_lock_test_and_set(&(v),(a))

 // v == c ? swap(v,a) return true : return false.
#define SC_ATOM_CMP(v,c,a) 
    __sync_bool_compare_and_swap(&(v), (cmp), (val))

//等待的秒数,因环境而定 2是我自己测试的一个值
#define _INT_USLEEP (2) 
#define SC_ATOM_LOCK(v) 
    while(SC_ATOM_SET(v,1)) { 
        usleep(_INT_USLEEP); 
    }

#define SC_ATOM_UNLOCK(v) 
    __sync_lock_release(&(v))


#endif /* _MSC_VER || __GNU__*/

#endif /*!_H_SC_ATOM*/

先将 这节的上面没出现过的api解析一下

// v == c ? swap(v,a) ; return true : return false.
#define SC_ATOM_COM(v,c,a) 
    ( c == InterlockedCompareExchange(&(v), (a), c))

首先是

#define InterlockedCompareExchange _InterlockedCompareExchange
/*
 *   原子操作,比较并交换,返回老的值 
 *  *Destination == Comperand 就交换 *Destination 和 ExChange,并返回交换后的
 * ExChange,如果不等 直接返回 *Destination
 */
LONG
CDECL_NON_WVMPURE
InterlockedCompareExchange (
    _Inout_ _Interlocked_operand_ LONG volatile * Destination,
    _In_ LONG ExChange,
    _In_ LONG Comperand
    );

这里

( c == InterlockedCompareExchange(&(v), (a), c)) 等价于

tmp = v; v==c ? v =a : ; return c == tmp; 

继续看看

#define SC_ATOM_CMP(v,c,a) 
    __sync_bool_compare_and_swap(&(v), (cmp), (val))

对于

bool __sync_bool_compare_and_swap (type *ptr, type oldval type newval, ...);
type __sync_val_compare_and_swap (type *ptr, type oldval type newval, ...);

These builtins perform an atomic compare and swap. That is, if the current value of *ptr is oldval, then write newval into *ptr. 
The “bool” version returns true if the comparison is successful and newval was written. The “val” version returns the contents of *ptr before the operation. 

第一条api意思就是 

tmp = *ptr ; *ptr == oldval ? *ptr = newval : ; return tmp == oldval;

第二个直接返回 tmp.

其实说的很简单,当你看到这你需要 看更多的资料,写 一点代码,才能 理解 它的作用,并可以在 以后的代码中使用它,轻巧的完成一些特定代码了.

到这里 不知道你是否和我一样兴奋,以后写 代码的速率又快乐一点.  扯一点,有一天去逛 一个 技术 站在云端的人的博文,底下有人评价 是这样的意思  "你也就是一个干了一辈子的技术狗".

思来思去,发现 能当一只 "狗" 也挺好, 至少 "狗的忠诚,狗的勇敢,狗对待朋友的热情" 太难得了.

最后总结,要想走得更远,还是少生气,少骂人的好,多行动,多给世界一点 热. 

4. Window 和 Linux 都简单测试一下

这个就轻松了,首先 是 Window 上测试案例 如下

#include <stdio.h>
#include <stdlib.h>
#include "sc_atom.h"
#include "pthread.h"

//1.0 简单的time帮助宏
#ifndef TIME_PRINT
#define TIME_PRINT(code) {
    clock_t __st,__et;
    __st=clock();
    code
    __et=clock();
    printf("当前代码块运行时间是:%lf秒
",(0.0+__et-__st)/CLOCKS_PER_SEC);
}
#endif /*!TIME_PRINT*/

//测试 的全局区变量,默认值为0
static int __cut;
//全局 锁
static int __lk;

//测试 原子锁操作
void* test_three(void* arg);

#define _INT_TIDS (50)
#define _INT_CUTS (2000000)

int main(int argc, char* argv[])
{
    pthread_t tids[_INT_TIDS];
    int i;

    puts("
原子锁操作数据如下:");
    __cut = 0;
    TIME_PRINT({
        for (i = 0; i < _INT_TIDS; ++i) {
            pthread_create(tids + i, NULL, test_three,NULL);
        }

    //等待结束
    for (i = 0; i < _INT_TIDS; ++i)
        pthread_join(tids[i],NULL);
    });
    printf("__cut = %d, __lk = %d
", __cut, __lk);

    system("pause");
    return 0;
}

//测试 原子锁操作
void*
test_three(void* arg)
{
    for (int i = 0; i < _INT_CUTS; ++i) {
        SC_ATOM_LOCK(__lk);
        ++__cut;
        SC_ATOM_UNLOCK(__lk);
    }

    return NULL;
}

运行的没有问题,效果理想 运行图如下:

速度还可以.采用 Window 10 x64 + VS2015 + Release + x86

下面是Linux 上 测试 案例

环境是 Ubuntu 15.10 x64 + gcc 5.2.1

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include "sc_atom.h"

//1.0 简单的time帮助宏
#ifndef TIME_PRINT
#define TIME_PRINT(code) {
    clock_t __st,__et;
    __st=clock();
    code
    __et=clock();
    printf("当前代码块运行时间是:%lf秒
",(0.0+__et-__st)/CLOCKS_PER_SEC);
}
#endif /*!TIME_PRINT*/

//测试 的全局区变量,默认值为0
static int __cut;
//全局 锁
static int __lk;

//测试 原子锁操作
void* test_three(void* arg);

#define _INT_TIDS (50)
#define _INT_CUTS (2000000)

int main(int argc, char* argv[])
{
    pthread_t tids[_INT_TIDS];
    int i;

    puts("
原子锁操作数据如下:");
    __cut = 0;
    TIME_PRINT({
        for (i = 0; i < _INT_TIDS; ++i) {
            pthread_create(tids + i, NULL, test_three,NULL);
        }

    //等待结束
    for (i = 0; i < _INT_TIDS; ++i)
        pthread_join(tids[i],NULL);
    });
    printf("__cut = %d, __lk = %d
", __cut, __lk);

    return 0;
}

//测试 原子锁操作
void*
test_three(void* arg)
{
    for (int i = 0; i < _INT_CUTS; ++i) {
        SC_ATOM_LOCK(__lk);
        ++__cut;
        SC_ATOM_UNLOCK(__lk);
    }

    return NULL;
}

测试效果截图如下

到这里 我们关于C中原子操作就告一段落,欢迎交流,互相提高. 有错误是肯定,指正之后马上改!

后记

一天过得好快,下次继续分享,一些关于C开发中一些技巧. 有好博文的同行多发广告,不加班就去贵空间中拜访交流学习的.