线程 - 随笔小屋

#include <pthread.h>
int pthread_create(pthread_t* tid, pthread_attr_t const* attr, void*(*start_routine)(void*), void* arg)
功能：创建新线程
参数：tid  输出线程ID。pthread_t 即 unlsigned long int
    attr  线程属性，NULL表示缺省属性
    start_routine  线程过程函数指针，所指向的函数将在被创建的线程中执行
    arg  传递给线程过程函数的参数
返回值：成功返回0,失败返回错误码

汇合线程

#include <pthread.h>
int pthread_join(pthread_t tid, void** retval);
功能：等待子线程终止，即其线程过程函数返回，并与之会合，同时回收该线程的资源
参数：tid  线程ID。
    retval  输出线程过程函数的返回值
返回值：成功返回0，失败返回错误码

分离线程

#include <pthread.h>
int pthread_detach(pthread_t tid);
功能：使指定的线程进入分离状态
参数：tid 线程的ID
返回值：成功返回0，失败返回错误码

线程id

#include <pthread.h>
pthread_t pthread_self(void);
返回调用线程的(POSIX线程库的)TID

#include <sys/syscall.h>
long int syscall(SYS_gettid);
返回调用线程的(系统内核的)TID

#include <pthread.h>
int pthread_equal(pthread_t t1, pthread_t t2);
两个参数所表示的TID相等返回非零，否则返回0

互斥锁

#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t* mutex, pthread_mutexattr_t const* attr);
功能:初始化互斥锁
参数:mutex  互斥锁
attr  互斥锁属性
返回值:成功返回0，失败返回错误码。
也可以静态方式初始化互斥锁:
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

#include <pthread.h>
int pthread_mutex_lock (pthread_mutex_t* mutex);
功能：锁定互斥锁
参数：mutex 互斥锁
成功：返回0，失败返回错误码

#include <pthread.h>
int pthread_mutex_unlock (pthread_mutex_t*mutex);
功能：解锁互斥锁
参数：mutex  互斥锁
成功：返回0，失败返回错误码

#include <pthread.h>
int pthread_mutex_destroy(pthread_mutex_t* mutex);
功能：销毁互斥锁
参数：mutex  互斥锁
返回值：成功返回0，失败返回错误码

//通过互斥锁解决并发冲突
#include<stdio.h>
#include<unistd.h>
#include<pthread.h>
int g_cn = 0;

//互斥锁
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

//线程过程函数
void* add(void* arg){
    //加锁
    //pthread_mutex_lock(&mutex);
    for(int i = 0;i < 1000000;i++){
        //加锁
        pthread_mutex_lock(&mutex);
        g_cn++;
        //解锁
        pthread_mutex_unlock(&mutex);
    }
    //解锁
    //pthread_mutex_unlock(&mutex);
    return NULL;
}

int main(void){
    pthread_t t1,t2;
    pthread_create(&t1,NULL,add,NULL);
    pthread_create(&t2,NULL,add,NULL);
    pthread_join(t1,NULL);
    pthread_join(t2,NULL);
    printf("g_cn = %d\n",g_cn);
    return 0;
}

条件变量

#include <pthread.h>
pthread_cond_init (pthread_cond_t* cond,const pthread_condattr_t* attr);
功能:初始化条件变量
参数: cond 条件变量
attr 条件变量属性
返回值:成功返回0，失败返回错误码
也可以静态方式初始化条件变量
pthread_cond_t cond= PTHREAD_COND_INITIALIZER;

#include <pthread.h>
pthread_cond_wait(pthread_cond_t* cond, pthread_mutex_t* mutex);
功能：睡入条件变量
参数：cond  条件变量
mutex 互斥锁
返回值：成功返回0，失败返回错误码

#include <pthread.h>
int pthread_cond_signal(pthread_cond_t*cond);
功能：唤醒在条件变量中睡眠的一个线程
参数：cond 条件变量
返回值：成功返回0，失败返回错误码

#include <pthread.h>
int pthread_cond_destroy(pthread_cond_t* cond)
功能：销毁条件变量
参数：cond 条件变量
返回值：成功返回0，失败返回错误码

//通过条件变量解决生产和消费问题
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>
char g_storage[10];//仓库
int g_stock = 0;//库存量
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;//互斥锁
pthread_cond_t pcond = PTHREAD_COND_INITIALIZER;//生产者卧室
pthread_cond_t ccond = PTHREAD_COND_INITIALIZER;//消费者卧室
//生产和消费过程  生产:ABC<---X     消费:ABC--->X
void show(char* who,char* op,char prod){
    printf("%s:",who);
    for(int i = 0;i < g_stock;i++){
        printf("%c",g_storage[i]);
    }
    printf("%s%c\n",op,prod);
}

//生产者线程
void* producer(void* arg){
    char* who = (char*)arg;
    for(;;){
        //加锁
        pthread_mutex_lock(&mutex);
        //判满
        if(g_stock == 10){
            printf("%s:满仓\n",who);
            pthread_cond_wait(&pcond,&mutex);
        }
        //生产
        char prod = 'A' + rand() % 26;
        show(who,"<---",prod);
        g_storage[g_stock] = prod;
        g_stock++;
        //唤醒消费者
        pthread_cond_signal(&ccond);
        //解锁
        pthread_mutex_unlock(&mutex);
        usleep((rand() % 100) * 1000);
    }
    return NULL;
}
//消费者线程
void* consumer(void* arg){
    char* who = (char*)arg;
    for(;;){
        //加锁
        pthread_mutex_lock(&mutex);
        //判空
        if(g_stock == 0){
            printf("%s:空仓\n",who);
            pthread_cond_wait(&ccond,&mutex);
        }
        //消费
        char prod = g_storage[--g_stock];
        show(who,"--->",prod);
        //唤醒生产者
        pthread_cond_signal(&pcond);
        //解锁
        pthread_mutex_unlock(&mutex);
        usleep((rand() % 100) * 1000);
    }
    return NULL;
}

int main(void){
    srand(getpid());
    pthread_t t1,t2;
    pthread_create(&t1,NULL,producer,"生产者");
    pthread_create(&t2,NULL,consumer,"消费者");
    getchar();
    return 0;
}