pthread 学习

1. 创建线程

　　int pthread_create (pthread_t* thread, pthread_attr_t* attr, void* (*start_routine)(void*), void* arg);

　　thread：线程句柄，用于标示一个线程；

　　attr（线程属性结构）：

　　1.__detachstate（同步状态）：

　　　　PTHREAD_CREATE_JOINABLE：结合的状态，在主线程退出之前，应该等待子线程完成；

　　　　PTHREAD_CREATE_DETACH：分离的状态，和主线程分离，自己运行结束后并释放资源；

　　2.__schedpolicy（调度策略）：

　　　　SCHED_OTHER：正常、非实时，默认状态

　　　　SCHED_RR：实时、轮转法

　　　　SCHED_FIFO：实时、先入先出

　　3.__schedparam：目前只有一个sched_priority（调度优先级）属性

　　4.__inheritsched：

　　　　PTHREAD_EXPLICIT_SCHED：显式指定调度策略和调度参数；

　　　　PTHREAD_INHERIT_SCHED：继承调用线程的参数；

　　5.__scope：

　　　　PTHREAD_SCOPE_SYSTEM：与系统中所有线程一起竞争CPU时间，默认值；

　　　　PTHREAD_SCOPE_PROCESS：与同进程中的线程竞争CPU；

　　start_routine：线程启动函数；

　　arg: 线程启动的时候，传递给启动函数的参数，如果没有就传入0；

设置属性的一些api：

　　pthread_attr_init(pthread_attr_t*)

　　pthread_attr_destroy(pthread_attr_t*)

　　pthread_attr_set－/get－ 一系列函数

2. 线程的取消

一个线程可以向另一个线程发送取消请求，来终止另一个线程的执行，不过另一个线程可以设置是否忽略取消请求，如果在不忽略的情况下，根据线程的设置，可能是执行到下一个取消点（Cancelation-point）才被终止执行，也可能是立即终止执行。

线程的取消点：

　　pthread_join()、pthread_testcancel()、pthread_cond_wait()、pthread_cond_timedwait()、sem_wait()、sigwait()等函数以及read()、write()会引起系统阻塞的函数都是取消点。

　　对于没有取消点的执行线程，我们可以在需要被取消执行的地方调用pthread_testcancel()，当一个线程接受到取消请求并没有忽略的情况下，一旦执行到pthread_testcancel()就会终止执行。

API:

int pthread_cancel(pthread_t); 向一个线程发送取消请求，成功返回0，否则返回非0，成功发送不代表已经完成取消；

int pthread_setcancelstate(int state, int *oldstate); 设置取消状态，有PTHREAD_CANCEL_ENABLE（缺省）和PTHREAD_CANCEL_DISABLE两种，第一种是接受取消请求，第二种是忽略取消请求。oldstate如果不为0，用于存入之前的取消状态，以便将来可以恢复。

int pthread_setcanceltype(int type, int *oldtype); 设置取消动作的时机，有PTHREAD_CANCEL_DEFFERED和PTHREAD_CANCEL_ASYCHRONOUS两种，第一种是执行到下一个取消点终止，第二种是立即终止执行。oldtype如果不为0，用于存入之前的值，以便将来可以恢复。

注：在unix环境下测试，两种情况都是运行到下一个取消点或者有pthread_testcancel()的位置才终止，不清楚具体原因。

3. 互斥锁

　　由于线程具有抢占式和共享资源的特点，因此需要用一种互斥机制来保证线程之间的同步，最常用的就是互斥锁。

创建互斥锁：

　　静态方式：pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

　　动态方式：int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr); mutexattr缺省值为0；

销毁互斥锁：

　　int pthread_mutex_destroy(pthread_mutex_t *mutex); 销毁锁占用的资源，如果锁定状态则返回EBUSY；

锁类型，在pthread_mutexattr_t（属性）中指定：

　　PTHREAD_MUTEX_TIMED_NP：普通锁（缺省值）。当一个线程加锁以后，其余请求锁的线程将形成一个等待队列，并在解锁后按优先级获得锁；

　　PTHREAD_MUTEX_RECURSIVE_NP：嵌套锁。允许同一个线程对同一个锁成功获得多次，并通过多次unlock解锁。如果是不同线程请求，则在加锁线程解锁时重新竞争；

　　PTHREAD_MUTEX_ERRORCHECK_NP：检错锁。如果同一个线程请求同一个锁，则返回EDEADLK，否则与PTHREAD_MUTEX_TIMED_NP类型动作相同。这样就保证当不允许多次加锁时不会出现最简单情况下的死锁；

　　PTHREAD_MUTEX_ADAPTIVE_NP：适应锁。动作最简单的锁类型，仅等待解锁后重新竞争；

锁操作：

　　无论是什么类型的锁，都只能被一个线程获取，不可能出现被两个线程同时获取到锁的情况。

　　普通锁和适应锁，解锁者可以是任何线程；

　　检错锁则必须由加锁者解锁才有效，否则返回EPERM；

　　嵌套锁，文档和实现要求必须由加锁者解锁；

　　int pthread_mutex_lock(pthread_mutex_t *mutex); 请求上锁，如果没有获取到锁，线程会被阻塞；

　　int pthread_mutex_unlock(pthread_mutex_t *mutex); 解锁；

　　int pthread_mutex_trylock(pthread_mutex_t *mutex); 请求上锁，如果成功获得一个锁，返回0，否则返回非0，该函数立即返回，不会阻塞；

锁机制并不是线程安全的，如果在线程上锁之后，解锁之前，被取消，就可能出现死锁的情况。这种情况需要使用线程退出回调函数来解锁。　

4. 条件变量

　　线程上锁之后，应该尽可能快的解锁，好让其他线程可以快速获取锁，以便提高程序性能。但无论如何，相关线程都会频繁的循环检测锁状态以便获取锁，例如可能在某种情况下，某个线程会在大部分时间上锁失败，这样不仅消耗了cpu周期，而且也是无意义的检测。因此，条件变量很好的改善了这种情况。

　　条件变量是一种线程间的同步机制。主要利用了一个共享的条件变量来进行同步，一个线程等待条件变量进行挂起，而一个线程在条件成立的时候，唤醒阻塞的线程。为了防止竞争和对资源的保护，条件变量总是和互斥锁一起使用。

创建条件变量：

　　静态方式：pthread_cond_t cond=PTHREAD_COND_INITIALIZER；

　　动态方式：int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);

　　int pthread_cond_destroy(pthread_cond_t *cond);

　　　　销毁条件变量，如果条件变量在被等待，返回EBUSY;

使用条件变量：

　　int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);

　　　　首先对mutex解锁（因此在调用pthread_cond_wait前，mutex必须处于锁定状态），然后等待cond的唤醒，此时该函数并不会立即返回而是被阻塞，直到cond被唤醒，然后对mutex上锁，该函数返回。

　　int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime);

　　　　和pthread_cond_wait类似，只是最有一个参数表明在规定时刻前条件没有成立，返回ETIMEOUT，并结束等待。

　　int pthread_cond_signal(pthread_cond_t*);　

　　　　唤醒队列中第一个线程；

　　int pthread_cond_broadcast();

　　　　唤醒所有等待条件变量的线程；

由于wait操作也是一个取消点，因此在wait操作结束之后，如果线程执行了取消操作，那么mutex会被一直锁定，造成死锁。这情情况需要使用退出回调函数来解锁。

　　

5. 终止线程

　　正常终止：函数调用return和执行pthread_exit(pthread_t)，这种是代码可以控制的终止情况；

　　异常终止：被其他线程取消，或者线程执行发生异常；

　　异常终止可能会导致资源不能被正常释放，其中包括锁，如果锁资源被解锁前，线程就异常终止了，那么其他线程将永远无法再获得该锁。

线程终止的清理：

　　使用pthread提供的清理函数（由于清理函数是宏定义，必须在同一层作用域成对出现，才能编译通过）：

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

　　　　入栈一个清理函数和需要清理的对象；

　　void pthread_cleanup_pop(int execute);

　　　　在线程退出的时候，执行栈中的清理函数；

　　清理函数会在自动释放资源，出现在函数对中的代码段的任何终止动作，都将执行清理函数。

　　如果需要在线程终止时，自动释放锁资源，可以使用：

　　　　pthread_cleanup_push(pthread_mutex_unlock, (void *) &mut);

　　　　pthread_mutex_lock(&mut);

　　　　......

　　　　pthread_mutex_unlock(&mut);

　　　　pthread_cleanup_pop(0);

线程的终止：

　　void pthread_exit(void *retval);

　　　　线程终止自己的执行，并清理资源。

　　int pthread_join(pthread_t th, void **thread_return);

　　　　合并线程，如果是joinable的子线程，通常在主线程结束之前，必须调用该函数等待子线程的执行完成，然和合并到主线程。thread_return如果不为0，保存线程的返回值。

　　int pthread_detach(pthread_t th);

　　　　分离线程，如果是detachable的子线程，它会在自己执行完成后，自动清理资源，主线程不需要等待它完成；

5. 线程私有数据（TSD）

　　int pthread_key_create(pthread_key_t *key, void (*destr_function) (void *));

　　该函数从TSD池中分配一项，将其值赋给key供以后访问使用。如果destr_function不为空，在线程退出（pthread_exit()）时将以key所关联的数据为参数调用destr_function()，以释放分配的缓冲区。

　　不论哪个线程调用pthread_key_create()，所创建的key都是所有线程可访问的，但各个线程可根据自己的需要往key中填入不同的值，这就相当于提供了一个同名而不同值的全局变量。

　　TSD池用一个结构数组表示:

　　　　static struct pthread_key_struct pthread_keys[PTHREAD_KEYS_MAX] = { { 0, NULL } };

　　创建一个TSD就相当于将结构数组中的某一项设置为"in_use"，并将其索引返回给*key，然后设置destructor函数为destr_function。

　　int pthread_key_delete(pthread_key_t key);

　　这个函数并不检查当前是否有线程正使用该TSD，也不会调用清理函数（destr_function），而只是将TSD释放以供下一次调用pthread_key_create()使用。在LinuxThreads中，它还会将与之相关的线程数据项设为NULL（见"访问"）。

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

　　void * pthread_getspecific(pthread_key_t key);

　　写入（pthread_setspecific()）时，将pointer的值（不是所指的内容）与key相关联，而相应的读出函数则将与key相关联的数据读出来。数据类型都设为void *，因此可以指向任何类型的数据。

实例：

//
//  main.c
//  threads
//
//  Created by avl-showell on 16/7/13.
//  Copyright © 2016年 avl-showell. All rights reserved.
//

#include <stdio.h>
#include <unistd.h>
#include "pthread.h"

pthread_t thread_1, thread_2, thread_3;
pthread_cond_t cond;
pthread_mutex_t mutex;
pthread_key_t key;

void* thread_1_func (void* arg) {
    static int i = ;

    const char* data = "tread1";
    pthread_setspecific(key, data);

    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, );
    pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, );

    pthread_cleanup_push(pthread_mutex_unlock, &mutex);

    while () {
        printf("thread 1 wait %s \n", pthread_getspecific(key));

        //pthread_cond_wait(&cond, &mutex);
        int state = pthread_mutex_trylock(&mutex);
            if (state == ) {

            printf("thread 1 start \n");

            //sleep(1);

            pthread_testcancel();

            i++;

            printf("thread 1 end %d \n", i);

            pthread_mutex_unlock(&mutex);
        }
        else {
            printf("thread 1 get lock failed... \n");
        }
    }

    pthread_cleanup_pop();

    return ;
}

void* thread_2_func (void* arg) {
    static int i = ;

    const char* data = "tread2";
    pthread_setspecific(key, data);

    while () {
        pthread_mutex_lock(&mutex);

        printf("thread 2 wait %s \n", pthread_getspecific(key));

        pthread_cond_wait(&cond, &mutex);

        printf("thread 2 start \n");

        //sleep(1);

        if (i == ) {
            pthread_cancel(thread_1);
        }
        if (i == ) {
            pthread_mutex_unlock(&mutex);
            pthread_exit();
        }
        i++;

        printf("thread 2 end %d \n", i);

        pthread_mutex_unlock(&mutex);
    }

    return ;
}

void* thread_3_func (void* arg) {
    static int i = ;

    while () {
        printf("thread 3 start \n");

        sleep();

        pthread_cond_signal(&cond);

        if (i == )
            break;
        i++;

        printf("thread 3 end \n");
    }

    return ;
}

void destroy (void* arg) {
    printf("pthread destroy key \n");
}

int main(int argc, const char * argv[]) {
    pthread_cond_init(&cond, );
    pthread_mutex_init(&mutex, );
    pthread_key_create(&key, destroy);

    if (pthread_create(&thread_1, , thread_1_func, )) {
        printf("thread 1 create failed... \n");
    }
    if (pthread_create(&thread_2, , thread_2_func, )) {
        printf("thread 2 create failed... \n");
    }
    if (pthread_create(&thread_3, , thread_3_func, )) {
        printf("thread 3 create failed... \n");
    }

    //sleep(5);

    pthread_join(thread_1, );
    pthread_join(thread_2, );
    pthread_join(thread_3, );

    pthread_cond_destroy(&cond);
    pthread_mutex_destroy(&mutex);
    pthread_key_delete(key);

    printf("exit \n");

    return ;
}