pthread_once_t once_control = PTHREAD_ONCE_INIT;//控制参数，用来确定是否已调用相关的初始化例程。

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

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

//发送终止信号给thread线程，如果成功则返回0，否则为非0值。发送成功并不意味着thread会终止。

int pthread_cancel(pthread_t thread);

//设置本线程对Cancel信号的反应，state有两种值：PTHREAD_CANCEL_ENABLE（缺省）和PTHREAD_CANCEL_DISABLE，

//分别表示收到信号后设为CANCLED状态和忽略CANCEL信号继续运行；old_state如果不为NULL则存入原来的Cancel状态以便恢复。

int pthread_setcancelstate(int state,int *oldstate);

//设置本线程取消动作的执行时机，type由两种取值：PTHREAD_CANCEL_DEFFERED和PTHREAD_CANCEL_ASYCHRONOUS，

//仅当Cancel状态为Enable时有效，分别表示收到信号后继续运行至下一个取消点再退出和立即执行取消动作（退出）

//oldtype如果不为NULL则存入运来的取消动作类型值。

int pthread_setcanceltype(int type,int *oldtype);

//pthread_testcancel在不包含取消点，但是又需要取消点的地方创建一个取消点，以便在一个没有包含取消点的执行代码线程中响应取消请求.

//线程取消功能处于启用状态且取消状态设置为延迟状态时，pthread_testcancel()函数有效。

//如果在取消功能处处于禁用状态下调用pthread_testcancel()，则该函数不起作用。

//请务必仅在线程取消线程操作安全的序列中插入pthread_testcancel()。除通过pthread_testcancel()调用以编程方式建立的取消点意外，

//pthread标准还指定了几个取消点。测试退出点,就是测试cancel信号.

void pthread_testcancel(void)

pthread_testcancel();

retcode = read(fd, buffer, length);

pthread_testcancel();

void thread_function(void *arg)

{

/**

* 线程准备执行一些关键工作，在这个过程中不希望被取消。

* 所以先通过pthread_setcancelstate()将本线程的cancel state

* 设为disabled。

*/

pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);

/* 执行关键工作 */

...

/**

* 关键工作执行完成，可以被取消。

* 通过pthread_setcancelstate()将本线程的cancel state

* 设为enabled。

*/

pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);

/**

* 调用pthread_testcancel()函数，检查一下在cancel state

* 为disabled状态的时候，是否有取消请求发送给本线程。

* 如果有的话就取消（退出）。

*/

pthread_testcancel();

/**

* pthread_testcancel()返回了，表明之前没有取消请求发送给本线程，

* 继续其余的工作。

* 这时候如果有取消请求发送给本线程，会在下一次执行到

* cancellation point的时候（例如sleep(), read(), write(), ...）时取消。

*/

...

/**

* 从这里开始，函数里不再包含cancellation point了。

* 如果收到取消请求，将无法取消。所以先把本线程的cancel type

* 设为asynchronous，收到取消请求将立即取消。

*/

pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);

/* 不包含cancellation point的代码 */

...

}

/* push the handler "routine" on cleanup stack */

void pthread_cleanup_push(void(*routine)(void *), void *args);

//如果弹出函数中的参数为非零值，则会从栈中删除该处理程序并执行该处理程序。如果该参数为零，则会弹出该处理程序，而不执行它。

void pthread_cleanup_pop(int execute);

/* pop the "func" out of cleanup stack and execute "func" */

pthread_cleanup_pop ();

/* pop the "func" and DONT execute "func" */

pthread_cleanup_pop (); 

    pthread_mutex_lock(&mutex);

    //一些会阻塞程序运行的调用，比如套接字的accept，等待客户连接,这里是随便找的一个可以阻塞的接口

    sock = accept(......);            

    pthread_mutex_unlock(&mutex);

    /*这个例子中，如果线程1执行accept时，线程会阻塞（也就是等在那里，有客户端连接的时候才返回，或则出现其他故障），线程等待中

    这时候线程2发现线程1等了很久，不赖烦了，他想关掉线程1，于是调用pthread_cancel()或者类似函数，请求线程1立即退出。

    这时候线程1仍然在accept等待中，当它收到线程2的cancel信号后，就会从accept中退出，然后终止线程，注意这个时候线程1还没有执行

    pthread_mutex_unlock(&mutex);也就是说锁资源没有释放，这回造成其他线程的死锁问题。*/

    /*所以必须在线程接收到cancel后用一种方法来保证异常退出(也就是线程没达到终点)时可以做清理工作(主要是解锁方面)

    pthread_cleanup_push与pthread_cleanup_pop就是这样的。*/

    pthread_cleanup_push(some_clean_func,...)

    pthread_mutex_lock(&mutex);

    //一些会阻塞程序运行的调用，比如套接字的accept，等待客户连接,里是随便找的一个可以阻塞的接口

    sock = accept(......);            这

    pthread_mutex_unlock(&mutex);

    pthread_cleanup_pop();

    return nullptr;

    /*上面的代码，如果accept被cancel后线程退出，会自动调用some_clean_func函数，在这个函数中你可以释放锁资源。

    如果accept没有被cancel，那么线程继续执行，当pthread_mutex_unlock(&mutex);表示线程自己正确的释放资源了，

    而执行pthread_cleanup_pop(0);也就是取消掉前面的some_clean_func函数。接着return线程就正确的结束了。*/

    //通俗点就是：

    /*pthread_cleanup_push注册一个回调函数，如果你的线程在对应的pthread_cleanup_pop之前异常退出(return是正常退出，

    其他是异常)，那么系统就会执行这个回调函数(回调函数要做什么你自己决定)。但是如果在pthread_cleanup_pop之前没有异常退出，

    pthread_cleanup_pop就把对应的回调函数取消了，*/

    //关于取消点的解释：

    //比如你执行：

            printf("thread sleep\n");

            sleep();

            printf("thread wake...\n");

   // 在sleep函数中，线程睡眠，结果收到cancel信号，这时候线程从sleep中醒来，但是线程不会立刻退出。

   //这是应为pthread与C库方面的原因，pthread的建议是，如果一个函数是阻塞的，

   //那么你必须在这个函数前后建立取消点,比如：

            printf("thread sleep\n");

            pthread_testcancel()；

            sleep();

            pthread_testcancel()；

            printf("thread wake...\n");

    //这样，就添加了两个取消掉。在执行到pthread_testcancel的位置时，线程才可能响应cancel退出进程。

#include <pthread.h>

pthread_key_t keyp;

//成功返回0，失败返回错误号。必须保证pthread_key_t只被创建一次，如果创建两次，第二个键覆盖第一个键

//第一个键与任何线程相关设置的值一起丢失

int pthread_key_create(pthread_key_t *keyp, void (*destructor)(void *));

//成功返回0，失败返回错误号。

int pthread_key_delete(pthread_key_t *key);

//返回线程特定数据，或者如果没有值关联到这个关键字时返回NULL。

void *pthread_getspecific(pthread_key_t key);

//成功返回0，失败返回错误号

int pthread_setspecific(pthread_key_t key, const void *value); 

void destructor(void *) 

pthread_key_t key; 

pthread_once_t init_done = PTHREAD_ONCE_INIT; 

void thread_init(void)

{

    err = pthread_key_create(&key, destructor);

}

int threadfunc(void *arg)

{

    pthread_once(&init_done, thread_init); //保证只被创建一次

    if( (ptr = pthread_getspecific(key)) == NULL ){

        ptr = malloc(len);

        pthread_setspecific(key,ptr);

        ...

    }

    ...

}

/** 示例1: 设置/获取线程特定数据

在两个线程中分别设置/获取线程特定数据, 查看两个线程中的数据是否是一样的(肯定是不一样的O(∩_∩)O~)

**/

pthread_key_t key;

typedef struct Tsd

{

    pthread_t tid;

    char *str;

} tsd_t;

//用来销毁每个线程所指向的实际数据，线程私有数据键的destruct函数在你替代键值时不会被调用，

void destructor_function(void *value)

{

    free(value);

    cout << "destructor ..." << endl;

}  

void *thread_routine(void *args)

{

    //设置线程特定数据

    tsd_t *value = (tsd_t *)malloc(sizeof(tsd_t));

    value->tid = pthread_self();

    value->str = (char *)args;

    pthread_setspecific(key, value);

    printf("%s setspecific, address: %p\n", (char *)args, value);  

    //获取线程特定数据

    value = (tsd_t *)pthread_getspecific(key);

    printf("tid: 0x%x, str = %s\n", (unsigned int)value->tid, value->str);

    sleep();  

    //再次获取线程特定数据

    value = (tsd_t *)pthread_getspecific(key);

    printf("tid: 0x%x, str = %s\n", (unsigned int)value->tid, value->str);  

    pthread_exit(NULL);

}  

int main()

{

    //这样每个线程当中都会有一个key可用了,

    //但是每个key所绑定的实际区域需要每个线程自己指定

    pthread_key_create(&key, destructor_function);  

    pthread_t tid1, tid2;

    pthread_create(&tid1, NULL, thread_routine, (void *)"thread1");

    pthread_create(&tid2, NULL, thread_routine, (void *)"thread2");  

    pthread_join(tid1, NULL);

    pthread_join(tid2, NULL);

    pthread_key_delete(key);  

    return ;

}  

/** 示例2:运用pthread_once, 让key只初始化一次

注意: 将对key的初始化放入到init_routine中

**/

pthread_key_t key;

pthread_once_t once_control = PTHREAD_ONCE_INIT;

typedef struct Tsd

{

    pthread_t tid;

    char *str;

} tsd_t;  

//线程特定数据销毁函数,

//用来销毁每个线程所指向的实际数据

void destructor_function(void *value)

{

    free(value);

    cout << "destructor ..." << endl;

}  

//初始化函数, 将对key的初始化放入该函数中,

//可以保证inti_routine函数只运行一次

void init_routine()

{

    pthread_key_create(&key, destructor_function);

    cout << "init..." << endl;

}  

void *thread_routine(void *args)

{

    pthread_once(&once_control, init_routine);  

    //设置线程特定数据

    tsd_t *value = (tsd_t *)malloc(sizeof(tsd_t));

    value->tid = pthread_self();

    value->str = (char *)args;

    pthread_setspecific(key, value);

    printf("%s setspecific, address: %p\n", (char *)args, value);  

    //获取线程特定数据

    value = (tsd_t *)pthread_getspecific(key);

    printf("tid: 0x%x, str = %s\n", (unsigned int)value->tid, value->str);

    sleep();  

    //再次获取线程特定数据

    value = (tsd_t *)pthread_getspecific(key);

    printf("tid: 0x%x, str = %s\n", (unsigned int)value->tid, value->str);  

    pthread_exit(NULL);

}  

int main()

{

    pthread_t tid1, tid2;

    pthread_create(&tid1, NULL, thread_routine, (void *)"thread1");

    pthread_create(&tid2, NULL, thread_routine, (void *)"thread2");  

    pthread_join(tid1, NULL);

    pthread_join(tid2, NULL);

    pthread_key_delete(key);  

    return ;

}