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 0; }
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=10; int j = i; ... int k = i;
由于编译器发现两次从i读数据的代码之间的代码没有对i进行过操作,它会自动把上次读的数据放在k中,而不是重新从i里面读。
又例如在嵌入式编程中,需要往某地址发送两条指令:
int *ip =...; //设备地址 *ip = 1; //第一个指令 *ip = 2; //第二个指令
以上代码可能会被编译器优化成:
int *ip = ...; *ip = 2;
导致第一条指令丢失。
如果用volatile关键字声明变量,就不允许编译器做优化:
volatile int *ip =...; //设备地址 *ip = 1; //第一个指令 *ip = 2; //第二个指令
定义为 volatile 的变量是说该变量可能会被意想不到地改变,这样,编译器就不会去假设这个变量的值了。准确地说就是,编译器在用到volatile变量时必须从内存读取,而不能使用保存在寄存器里的值。
下面是volatile变量的几个例子:
- 并行设备的硬件寄存器(如:状态寄存器);
- 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables);
- 多线程应用中的共享变量;
volatile在多线程环境中的应用,可以先看下面的例子:
volatile long int n = 0; void foo() { int i; for(i=0; i<10000; i++) { n++; } } #define N 100 int main() { int k; pthread_t th[N]; for (k=0; k<N; k++) { pthread_create(&th[k], NULL, (void*)foo, NULL); } for (k=0; k<N; k++) { pthread_join(th[k], NULL); } printf("n=%ld\n", n); return 0; }
并发100个线程,每个线程对共享变量n累加1万次,理论上最后的结果应该是100w,但代码实际结果却是比这个更小的一个随机值。
我们知道volatile修饰的变量在每次被线程访问时,都强迫从内存中重读该变量的值。而且,当变量值发生变化时,强迫线程将变化值回写到内存。这样在任何时刻,两个不同的线程总是看到某个变量的同一个值。
既然如此,为何每次结果还是不同呢,这是因为n++操作并非原子性,也就是说volatile不能保证所修饰的变量进行原子操作。
以汇编过程来看自增操作:
mov eax,dword ptr [ebp-8] ;把i的值mov到eax寄存器 add eax,1 ;自加 mov dword ptr [ebp-8],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);