extern、static、restrict、volatile 关键字

extern

extern的两个作用：

修饰变量或函数，提示编译器此变量或函数是在其它文件中定义的，但要在此处引用；
进行链接指定，如: extern "C" void fun(int a, int b); 告诉编译器在编译fun这个函数名时按着C的规则去翻译相应的函数名而不是C++的，；

static

static的主要作用：

static局部变量，静态变量，函数返回时不会销毁；
static全局变量，仅在当前文件可见；
static函数，仅在当前文件可见；
修饰类成员，静态成员为所有对象所有，不属于某个特定的对象；static成员函数没有this指针，只能访问类的static成员变量；

另外，static变量如果没有初始化，会自动用0填充；

例子：用static成员实现singleton模式，

class Singleton{

public:

    static Singleton* getInstance() {

        if(!sg) {

            sg = new Singleton();   //创建实例，但在哪里释放呢？

        }

        return sg;

    } 

private:

    Singleton() { }            //构造函数声明为私有函数

    static Singleton *sg;   //私有静态变量

};  

//初始化静态变量sg为0，不指向任何对象

Singleton* Singleton::sg = NULL; 

int main(){

    Singleton *sg = Singleton::getInstance(); 

    return ;

}

restrict

restrict 仅能修饰指针，用于告诉编译器只能通过该指针修改其指向的对象（内存区域），也就是说restrict指针将独占所指的内存，所有修改都得通过这个指针来，编译器可以放心大胆地把这片内存中前若干字节用寄存器cache起来。

例如下面两个C库函数，都是从s2指向的位置复制n字节数据到s1指向的位置，且均返回s1的值。两者之间的差别由关键字restrict造成，即memcpy假定两个内存区域没有重叠；memmove函数则不做这个假定。

void * memcpy（void * restrict s1, const void * restrict s2, size_t n);

void * memove(void * s1, const void * s2, size_t n);

volatile

volatile 变量是随时可能发生变化的，编译器不要对其进行优化，以免出错。

例如：

int i=;

int j = i;

...

int k = i;

由于编译器发现两次从i读数据的代码之间的代码没有对i进行过操作，它会自动把上次读的数据放在k中，而不是重新从i里面读。

又例如在嵌入式编程中，需要往某地址发送两条指令：

int *ip =...;     //设备地址

*ip = ;     //第一个指令

*ip = ;     //第二个指令

以上代码可能会被编译器优化成：

int *ip = ...;

*ip = ;

导致第一条指令丢失。

如果用volatile关键字声明变量，就不允许编译器做优化：

volatile int *ip =...;     //设备地址

*ip = ;     //第一个指令

*ip = ;     //第二个指令

定义为 volatile 的变量是说该变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。准确地说就是，编译器在用到volatile变量时必须从内存读取，而不能使用保存在寄存器里的值。

下面是volatile变量的几个例子：

并行设备的硬件寄存器（如：状态寄存器）；
一个中断服务子程序中会访问到的非自动变量（Non-automatic variables）；
多线程应用中的共享变量；

volatile在多线程环境中的应用，可以先看下面的例子：

volatile long int n = ;

void foo()

{

    int i;

    for(i=; i<; i++) {

        n++;

    }

}

#define N 100

int main()

{

    int k;

    pthread_t th[N];

    for (k=; k<N; k++) {

        pthread_create(&th[k], NULL, (void*)foo, NULL);

    }   

    for (k=; k<N; k++) {

        pthread_join(th[k], NULL);

    }   

    printf("n=%ld\n", n);

    return ;

}

并发100个线程，每个线程对共享变量n累加1万次，理论上最后的结果应该是100w，但代码实际结果却是比这个更小的一个随机值。

我们知道volatile修饰的变量在每次被线程访问时，都强迫从内存中重读该变量的值。而且，当变量值发生变化时，强迫线程将变化值回写到内存。这样在任何时刻，两个不同的线程总是看到某个变量的同一个值。

既然如此，为何每次结果还是不同呢，这是因为n++操作并非原子性，也就是说volatile不能保证所修饰的变量进行原子操作。

以汇编过程来看自增操作：

mov        eax,dword ptr [ebp-]     ;把i的值mov到eax寄存器

add        eax,                     ;自加

mov        dword ptr [ebp-],eax     ;再存放至i变量中

分为3个步骤：

1）读取volatile变量值到寄存器；

2）增加寄存器的值；

3）把寄存器的值回写内存；

可见，如果线程A在步骤2、3之间被另一个线程B抢占，线程B对共享变量完成一次自增，等到线程A继续完成步骤3时，就丢失了线程B的这次操作。

要解决上面的多线程如何正确使用共享变量的问题，通常需要加锁，或者使用原子变量。

先来看X86架构下面原子变量的定义：

typedef struct {

    volatile int counter;

} atomic_t;

原子类型其实是 int 类型，只是使用volatile禁止寄存器对其暂存。

原子操作的API：

atomic_read(atomic_t * v);                   // v

atomic_set(atomic_t * v, int i);             // v = i

void atomic_add(int i, atomic_t *v);         // v += i

void atomic_sub(int i, atomic_t *v);         // v -= i

void atomic_inc(atomic_t *v);                // v++

void atomic_dec(atomic_t *v);                // v--

int atomic_dec_and_test(atomic_t *v);        // (--v)==0?true:false

int atomic_inc_and_test(atomic_t *v);         // (++v)==0?true:false

int atomic_sub_and_test(int i, atomic_t *v);  // (v-i)==0?true:false

int atomic_add_negative(int i, atomic_t *v);  // (v+i)<0?true:false

int atomic_add_return(int i, atomic_t *v);

int atomic_sub_return(int i, atomic_t *v);

int atomic_inc_return(atomic_t * v);

int atomic_dec_return(atomic_t * v);