最近遇到些比较语法糖的知识，记录下来防止忘记。

1. likely与unlikely

likely与unlikely是Kernel中提供的两个宏，在Linux 2.6版本中，两个宏的定义如下：

#define likely(x) __builtin_expect(!!(x), 1)
#define unlikely(x) __builtin_expect(!!(x), 0)

由于现代CPU都使用流水线的技术，在执行当前机器指令时，下一条机器指令已经被读入寄存器；因此，使用likely与unlikely宏，使得程序员可以把条件判断的分支概率分布情况告诉编译器，从而提高流水线中指令命中的概率，提高执行效率。
以下面一段代码为例：

// 使用likely
#include <stdio.h>
#include <stdlib.h>

#define likely(x) __builtin_expect(!!(x), 1)
#define unlikely(x) __builtin_expect(!!(x), 0)

int main(int argc, char** argv)
{
    int num;
    num = atoi(argv[1]);
    int a = 1;
    int b = 2;

    if(likely(num == 0xFF))
    {
        printf("a=%d", a);
    }
    else
    {
        printf("b=%d", b);
    }
    return 0;
}

//使用unlikely
#include <stdio.h>
#include <stdlib.h>

#define likely(x) __builtin_expect(!!(x), 1)
#define unlikely(x) __builtin_expect(!!(x), 0)

int main(int argc, char** argv)
{
    int num;
    num = atoi(argv[1]);
    int a = 1;
    int b = 2;

    if(unlikely(num == 0xFF))
    {
        printf("a=%d", a);
    }
    else
    {
        printf("b=%d", b);
    }
    return 0;
}

上面两个源码文件唯一的差异就是在进行条件判断的时候，使用了likely/unlikely，由此编译产生的汇编机器码差异如下：

汇编机器码对比

可以看出，在likely/unlikely加持之下，GCC会有倾向性地安排汇编码顺序，提高执行效率。

2. pthread_once执行多线程唯一的初始化

有时候我们需要对一些posix变量只进行一次初始化，如果我们进行多次初始化程序就会出现错误。通常，一次性初始化经常通过使用布尔变量来管理。控制变量被静态初始化为0，而任何依赖于初始化的代码都能测试该变量：如果变量值仍然为0，则它能实行初始化，然后将变量置为1。以后检查的代码将跳过初始化。

但是在多线程程序设计中，事情就变的复杂的多。如果多个线程并发地执行初始化序列代码，可能有2个线程发现控制变量为0，并且都实行初始化，而该过程本该仅仅执行一次。pthread_once就可以解决这个问题。

int pthread_once(pthread_once_t *once_control, void (*init_routine) (void))；

功能：pthread_once使用初值为PTHREAD_ONCE_INIT的once_control变量保证init_routine()函数在本进程执行序列中仅执行一次。

在多线程编程环境下，尽管pthread_once()调用会出现在多个线程中，init_routine()函数仅执行一次，究竟在哪个线程中执行是不定的，是由内核调度来决定。

Linux Threads使用互斥锁和条件变量保证由pthread_once()指定的函数执行且仅执行一次，而once_control表示是否执行过。具体使用方法请参考以下代码：

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

pthread_once_t once_instance = PTHREAD_ONCE_INIT;

void once_func(void)
{
    printf("once_func run in thread:%ld\n", pthread_self());
    return;
}

void * thread1(void* arg)
{
    pthread_t tid = pthread_self();
    printf("enter thread-%ld\n", tid);
    pthread_once(&once_instance, once_func);
    printf("leave thread-%ld\n", tid);
}

void * thread2(void* arg)
{
    pthread_t tid = pthread_self();
    printf("enter thread-%ld\n", tid);
    pthread_once(&once_instance, once_func);
    printf("leave thread-%ld\n", tid);
}

int main()
{
    pthread_t tid1, tid2;
    printf("test start\n");
    pthread_create(&tid1, NULL, thread1, NULL);
    pthread_create(&tid2, NULL, thread2, NULL);
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    printf("main thread exit\n");
    return 0;
}

运行结果如下：

test start
enter thread-140572446230272
once_func run in thread:140572446230272
leave thread-140572446230272
enter thread-140572437837568
leave thread-140572437837568
main thread exit

可见，once_func在多线程环境下只执行了一次，证明pthread_once适用于多线程环境下只执行一次（常见于初始化）的语义。