linux-pthread-多线程编程

线程按照其调度者可以分为用户级线程和核心级线程两种 
用户级线程主要解决的是上下文切换的问题，它的调度算法和调度过程全部由用户自行选择决定，在运行时不需要特定的内核支持； 
我们常用基本就是用户级线程，所以就只总结一下POSIX提供的用户级线程接口； 
基本线程操作相关的函数： 
1线程的建立结束 
2线程的互斥和同步 
3使用信号量控制线程 
4线程的基本属性配置 

基本线程操作：

函数	说明	函数声明	返回值	参数
pthread_start()	创建线程开始运行相关线程函数，运行结束则线程退出	int pthread_create(pthread_t *tidp,const pthread_attr_t *attr,void*（*start_rtn)(void*),void *arg);	若成功则返回0，否则返回出错编号	第一个参数为指向线程标识符的指针。 第二个参数用来设置线程属性。 第三个参数是线程运行函数的地址。 最后一个参数是运行函数的参数。
pthread_exit()	线程的终止可以是调用了pthread_exit或者该线程的例程结束。也就是说，一个线程可以隐式的退出，也可以显式的调用pthread_exit函数来退出。 pthread_exit函数唯一的参数value_ptr是函数的返回代码，只要pthread_join中的第二个参数value_ptr不是NULL，这个值将被传递给value_ptr。	void pthread_exit( void * value_ptr );		参数——函数的返回代码
pthread_join()	挂起当前线程，用于阻塞式地等待线程结束，如果线程已结束则立即返回，0=成功	int pthread_join(pthread_t thread, void **retval);	成功返回0,失败返回错误号	第一个参数为指向线程标识符的指针。 第二个参数为接收退出线程传递出的返回值
pthread_cancel()	发送终止信号给thread线程，成功返回0，但是成功并不意味着thread会终止	int pthread_cancel(pthread_t thread);		第一个参数为指向线程标识符的指针。(返回-1)
pthread_testcancel()	在不包含取消点，但是又需要取消点的地方创建一个取消点，以便在一个没有包含取消点的执行代码线程中响应取消请求.	void pthread_testcancel(void)
pthread_setcancelstate()	设置本线程对Cancel信号的反应	int pthread_setcancelstate(int state,   int *oldstate)		state有两种值：PTHREAD_CANCEL_ENABLE（缺省）和PTHREAD_CANCEL_DISABLE，分别表示收到信号后设为CANCLED状态和忽略CANCEL信号继续运行
pthread_setcanceltype()	设置取消状态 继续运行至下一个取消点再退出或者是立即执行取消动作	int pthread_setcanceltype(int type, int *oldtype)		type由两种取值：PTHREAD_CANCEL_DEFFERED和PTHREAD_CANCEL_ASYCHRONOUS，仅当Cancel状态为Enable时有效，分别表示收到信号后继续运行至下一个取消点再退出和立即执行取消动作（退出）；oldtype如果不为NULL则存入运来的取消动作类型值。

互斥与同步机制基本函数(静态初始化锁变量->pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;)

函数	说明	函数声明	参数
pthread_mutex_init()	互斥锁的初始化	int pthread_mutex_init(pthread_mutex_t *mutex,const pthread_mutexattr_t *attr);	attr->* PTHREAD_MUTEX_TIMED_NP，这是缺省值，也就是普通锁。当一个线程加锁以后，其余请求锁的线程将形成一个等待队列，并在解锁后按优先级获得锁。这种锁策略保证了资源分配的公平性。 * PTHREAD_MUTEX_RECURSIVE_NP，嵌套锁，允许同一个线程对同一个锁成功获得多次，并通过多次unlock解锁。如果是不同线程请求，则在加锁线程解锁时重新竞争。 * PTHREAD_MUTEX_ERRORCHECK_NP，检错锁，如果同一个线程请求同一个锁，则返回EDEADLK，否则与PTHREAD_MUTEX_TIMED_NP类型动作相同。这样保证当不允许多次加锁时不出现最简单情况下的死锁。 * PTHREAD_MUTEX_ADAPTIVE_NP，适应锁，动作最简单的锁类型，仅等待解锁后重新竞争。
pthread_mutex_lock	锁定互斥锁，如果尝试锁定已经被上锁的互斥锁则阻塞至可用为止	int pthread_mutex_lock(pthread_mutex_t *mutex)
pthread_mutex_unlock()	释放互斥锁	int pthread_mutex_unlock(pthread_mutex_t *mutex)
pthread_mutex_destory()	互斥锁销毁函数	int pthread_mutex_destroy(pthread_mutex_t *mutex)

互斥与同步机制基本函数

函数	说明	函数声明	参数
sem_init	初始化一个定位在sem的匿名信号量	int sem_init(sem_t *sem, int pshared, unsigned int value);	其中sem是要初始化的信号量，pshared表示此信号量是在进程间共享还是线程间共享，value是信号量的初始值。
sem_destroy	销毁由sem指向的匿名信号量	int sem_destroy(sem_t *sem);	其中sem是要销毁的信号量。只有用sem_init初始化的信号量才能用sem_destroy销毁
sem_wait	把信号量减1操作，如果信号量的当前值为0则进入阻塞，为原子操作	int sem_wait(sem_t *sem);	等待信号量，如果信号量的值大于0,将信号量的值减1,立即返回。如果信号量的值为0,则线程阻塞。相当于P操作。成功返回0,失败返回-1
sem_post	给信号量的值加1，它是一个“原子操作”，即同时对同一个信号量做加1,操作的两个线程是不会冲突的	int sem_post(sem_t *sem);	释放信号量，让信号量的值加1。相当于V操作。

线程属性配置相关函数

函数	说明	函数声明	返回值	参数
pthread_attr_init/pthread_attr_destroy	对线程属性初始化/去除初始化	int pthread_attr_init(pthread_attr_t*attr); int pthread_attr_destroy(pthread_attr_t*attr);	若成功返回0，若失败返回-1。	Attr   线程属性变量
pthread_attr_getdetachstate/pthread_attr_setdetachstate	获取/修改线程的分离状态属性 在默认情况下线程是非分离状态的，只有当pthread_join（）函数返回时，创建的线程才算终止，才能释放自己占用的系统资源。分离线程没有被其他的线程所等待，自己运行结束了，线程也就终止了，马上释放系统资源。	int pthread_attr_getdetachstate(const pthread_attr_t *attr,int *detachstate); int pthread_attr_setdetachstate(pthread_attr_t *attr,int detachstate);	若成功返回0，若失败返回-1。	Attr   线程属性变量 Detachstate  线程的分离状态属性(PTHREAD_CREATE_DETACHED,以分离状态启动线程；或者设置为PTHREAD_CREATE_JOINABLE,正常启动线程)
pthread_attr_getinheritsched/pthread_attr_setinheritsched	获得/设置线程的继承性	int pthread_attr_getinheritsched(const pthread_attr_t*attr,int *inheritsched); int pthread_attr_setinheritsched(pthread_attr_t *attr,intinheritsched);	若成功返回0，若失败返回-1。	attr            线程属性变量 inheritsched     线程的继承性(继承性的可能值是PTHREAD_INHERIT_SCHED（表示新现成将继承创建线程的调度策略和参数）和PTHREAD_EXPLICIT_SCHED（表示使用在schedpolicy和schedparam属性中显式设置的调度策略和参数))
pthread_attr_getschedpolicy/pthread_attr_setschedpolicy	获得/设置线程的调度策略	int pthread_attr_getschedpolicy(const pthread_attr_t*attr,int *policy); int pthread_attr_setschedpolicy(pthread_attr_t *attr,intpolicy);	若成功返回0，若失败返回-1。	attr           线程属性变量 policy         调度策略(调度策略可能的值是先进先出（SCHED_FIFO）、轮转法（SCHED_RR）,或其它（SCHED_OTHER))
pthread_attr_getschedparam/pthread_attr_setschedparam	获得/设置线程的调度参数	int pthread_attr_getschedparam(const pthread_attr_t*attr,struct sched_param *param); int pthread_attr_setschedparam(pthread_attr_t *attr,conststruct sched_param *param);	若成功返回0，若失败返回-1。	结构sched_param的子成员sched_priority控制一个优先权值，大的优先权值对应高的优先权。系统支持的最大和最小优先权值可以用sched_get_priority_max函数和sched_get_priority_min函数分别得到。

下面我们举几个简单的例子讲解一下这些函数的使用

首先我们来看pthread_create，pthread_join的使用

/* thread.c */
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

#define THREAD_NUMBER       3                 /*线程数*/
#define REPEAT_NUMBER       5                 /*每个线程中的小任务数*/
#define DELAY_TIME_LEVELS  10.0             /*小任务之间的最大时间间隔*/
//
void *thrd_func(void *arg) { 
    /* 线程函数例程 */
    int thrd_num = (int)arg;
    int delay_time = 0;
    int count = 0;
    printf("Thread %d is starting\n", thrd_num);
    for (count = 0; count < REPEAT_NUMBER; count++) {
        delay_time = (int)(rand() * DELAY_TIME_LEVELS/(RAND_MAX)) + 1;
        sleep(delay_time);
        printf("\tThread %d: job %d delay = %d\n", 
                      thrd_num, count, delay_time);
    }

    printf("Thread %d finished\n", thrd_num);
    pthread_exit(NULL);
}

int main(void) {
     pthread_t thread[THREAD_NUMBER];
     int no = 0, res;
     void * thrd_ret;
     srand(time(NULL));    
     for (no = 0; no < THREAD_NUMBER; no++) {
          /* 创建多线程 */
          res = pthread_create(&thread[no], NULL, thrd_func, (void*)no);
          if (res != 0) {
               printf("Create thread %d failed\n", no);
               exit(res);
          }
     }

     printf("Create treads success\n Waiting for threads to finish...\n");
     for (no = 0; no < THREAD_NUMBER; no++) {
          /* 等待线程结束 */
          res = pthread_join(thread[no], &thrd_ret);
          if (!res) {
            printf("Thread %d joined\n", no);
          } else {
            printf("Thread %d join failed\n", no);
          }
     }
     return 0;        
}

我们发现 pthread_join会按顺序调用，即使后面的pthread结束，也需要等待前面的pthread，pthread_join运行结束，才会执行对应的pthread_join

接下来我们来看互斥锁的使用

/*thread_mutex.c*/
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

#define THREAD_NUMBER        3            /* 线程数 */
#define REPEAT_NUMBER        3            /* 每个线程的小任务数 */
#define DELAY_TIME_LEVELS 10.0         /*小任务之间的最大时间间隔*/
pthread_mutex_t mutex;

void *thrd_func(void *arg) {
     int thrd_num = (int)arg;
     int delay_time = 0, count = 0;
     int res;
     /* 互斥锁上锁 */
     res = pthread_mutex_lock(&mutex);
     if (res) {
          printf("Thread %d lock failed\n", thrd_num);
          pthread_exit(NULL);
     }
     printf("Thread %d is starting\n", thrd_num);
     for (count = 0; count < REPEAT_NUMBER; count++) {          
         delay_time = (int)(rand() * DELAY_TIME_LEVELS/(RAND_MAX)) + 1;
         sleep(delay_time);
         printf("\tThread %d: job %d delay = %d\n", 
                                      thrd_num, count, delay_time);
     }
     printf("Thread %d finished\n", thrd_num);
     pthread_mutex_unlock(&mutex); 
     pthread_exit(NULL);
}

int main(void) {
     pthread_t thread[THREAD_NUMBER];
     int no = 0, res;
     void * thrd_ret;

     srand(time(NULL));
     /* 互斥锁初始化 */
     pthread_mutex_init(&mutex, NULL);
     for (no = 0; no < THREAD_NUMBER; no++) {
          res = pthread_create(&thread[no], NULL, thrd_func, (void*)no);
          if (res != 0) {
              printf("Create thread %d failed\n", no);
              exit(res);
          }
     }     
     printf("Create treads success\n Waiting for threads to finish...\n");
     for (no = 0; no < THREAD_NUMBER; no++) {
          res = pthread_join(thread[no], &thrd_ret);
          if (!res) {
                printf("Thread %d joined\n", no);
          } else  {
              printf("Thread %d join failed\n", no);
          }
     }   
     /****互斥锁解锁***/
     //pthread_mutex_unlock(&mutex); // 互斥锁需要在线程中进行解锁
     pthread_mutex_destroy(&mutex);          
     return 0;        
}

然后我们来看信号量的使用

/* thread_sem.c */
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>

#define THREAD_NUMBER       3
#define REPEAT_NUMBER       3
#define DELAY_TIME_LEVELS   10.0

sem_t sem[THREAD_NUMBER];

void * thrd_func(void *arg) {
    int thrd_num = (int)arg;
    int delay_time = 0;
    int count = 0;
    sem_wait(&sem[thrd_num]);
    printf("Thread %d is starting\n", thrd_num);
    for (count = 0; count < REPEAT_NUMBER; count++) {
        delay_time = (int)(rand() * DELAY_TIME_LEVELS/(RAND_MAX)) + 1;
        sleep(delay_time);
        printf("\tThread %d: job %d delay = %d\n", thrd_num, count, delay_time);
    }
    printf("Thread %d finished\n", thrd_num);
    pthread_exit(NULL);
}

int main(void) {
    pthread_t thread[THREAD_NUMBER];
    int no = 0, res;
    void * thrd_ret;
    srand(time(NULL));
    for (no = 0; no < THREAD_NUMBER; no++) {
        sem_init(&sem[no], 0, 0);
        res = pthread_create(&thread[no], NULL, thrd_func, (void*)no);
        if (res != 0) {
            printf("Create thread %d failed\n", no);
            exit(res);
        }
    }

    printf("Create treads success\n Waiting for threads to finish...\n");
    sem_post(&sem[THREAD_NUMBER - 1]);
    for (no = THREAD_NUMBER - 1; no >= 0; no--) {
        res = pthread_join(thread[no], &thrd_ret);
        if (!res) {
            printf("Thread %d joined\n", no);
        } else {
            printf("Thread %d join failed\n", no);
        }
        sem_post(&sem[(no + THREAD_NUMBER - 1) % THREAD_NUMBER]);           
    }

    for (no = 0; no < THREAD_NUMBER; no++) {
        sem_destroy(&sem[no]);      
    }
    return 0;        
}

最后我们来看看属性配置中的分离属性怎么使用

/* thread_attr.c */
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

#define THREAD_NUMBER       1
#define REPEAT_NUMBER       3
#define DELAY_TIME_LEVELS   10.0
int finish_flag = 0;

void * thrd_func(void * arg){
    int delay_time = 0;
    int count = 0;
    printf("Thread is starting\n");
    for (count = 0; count < REPEAT_NUMBER; count++) {
        delay_time = (int)(rand() * DELAY_TIME_LEVELS/(RAND_MAX)) + 1;
        sleep(delay_time);
        printf("\tThread : job %d delay = %d\n", count, delay_time);
    }
    printf("Thread finished\n");
    finish_flag = 1;
    pthread_exit(NULL);
}

int main(void) {
    pthread_t thread;
    pthread_attr_t attr;
    int res = 0;
    srand(time(NULL));
    res = pthread_attr_init(&attr);
    if (res != 0) {
        printf("Create attribute failed\n");
        exit(res);
    }
    res = pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
    res += pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
    if (res != 0) {
        printf("Setting attribute failed\n");
        exit(res);
    }
    res = pthread_create(&thread, &attr, thrd_func, NULL);
    if (res != 0) {
        printf("Create thread failed\n");
        exit(res);
    }
    pthread_attr_destroy(&attr);
    printf("Create tread success\n");

    while(!finish_flag){
        printf("Waiting for thread to finish...\n");
        sleep(2);
    }
    return 0;        
}