Linux多线程开发

线程概述

线程创建

一般情况下，main函数所在的线程我们称之为主线程，其余创建的线程称之为子线程

程序中默认只有一个进程，fork()函数调用，2个进程

程序中默认只有一个线程，pthread_create()函数调用，2个线程

#include <pthread.h>

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,

void *(*start_routine) (void *), void *arg);

功能：创建一个子线程

参数：

thread：传出参数，线程创建成功后，子线程的线程ID被写到该变量中

attr：设置线程的属性，一般使用默认值，NULL

start_routine：函数指针，这个函数是子线程需要处理的逻辑代码

arg：给第三个参数使用，传参

返回值：

成功：0

失败：返回错误号，这个错误号和之前errno不太一样

获取错误号信息，char *strerror(int errnum); //#include <string.h>
cpp 复制代码
#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <unistd.h>

void *callback(void *arg)
{
    printf("child thread...\n");
    printf("arg value :%d\n",*(int *)arg);
    return NULL;
}

int main()
{
    pthread_t tid;

    int num = 10;
    //创建一个子线程
    int ret = pthread_create(&tid,NULL,callback,(void*)&num);

    if(ret != 0)
    {
        char *errstr = strerror(ret);
        printf("error : %s\n",errstr);
    }

    for(int i = 0;i < 5;i ++)
    {
        printf("%d\n",i);
    }
    sleep(1);

    return 0;
}

线程终止

#include <pthread.h>

void pthread_exit(void *retval);

功能：终止一个线程，在哪个线程中调用，就表示终止哪个线程

参数：

reval：需要传递一个指针，作为一个返回值，可以在pthread_join()中

pthread_t pthread_self(void);

功能：获取当前的线程的线程ID

int pthread_equal(pthread_t t1,pthread_t t2);

功能：比较两个线程ID是否相等

不同的操作系统，pthread_t类型的实现，有的是无符号的长整型，有的是使用结构体去实现的
cpp 复制代码
#include <stdio.h>
#include <pthread.h>
#include <string.h>
void *callback(void *arg)
{
    printf("child thread id:%ld\n",pthread_self());
    return NULL; //pthread_exit(NULL)
}
int main()
{
    //创建一个子线程
    pthread_t tid;
    int ret = pthread_create(&tid,NULL,callback,NULL);
    if(ret != 0)
    {
        char *errstr = strerror(ret);
        printf("error:%s\n",errstr);
    }

    //主线程
    for(int i = 0;i < 5;i ++)
    {
        printf("%d\n",i);
    }
    printf("tid :%ld ,main thread id:%ld\n",tid,pthread_self());

    //让主线程退出
    pthread_exit(NULL);

    return 0;
}

#include <pthread.h>

int pthread_join(pthread_t thread, void **retval);

功能：和一个已经终止的线程进行连接

回收子线程的资源，这个函数是阻塞函数，调用一次只能回收一个子线程，

一般在主线程中使用

参数：

thread：需要回收的子线程的ID

retval：接收子线程退出时的返回值

返回值：

0：成功

非0：失败，返回的错误号

cpp 复制代码

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

int value = 10;
void *callback(void *arg)
{
    printf("child thread id:%ld\n",pthread_self());
    //sleep(3);
    pthread_exit((void*)&value);
}

int main()
{
    //创建一个子线程
    pthread_t tid;
    int ret = pthread_create(&tid,NULL,callback,NULL);
    if(ret != 0)
    {
        char *errstr = strerror(ret);
        printf("error:%s\n",errstr);
    }

    //主线程
    for(int i = 0;i < 5;i ++)
    {
        printf("%d\n",i);
    }
    printf("tid :%ld ,main thread id:%ld\n",tid,pthread_self());

    //主线程调用pthread_join()回收子线程的资源
    int *thread_retval;
    ret = pthread_join(tid,(void **)&thread_retval);//不需要传参则可以写NULL
    if(ret != 0)
    {
        char *errstr = strerror(ret);
        printf("error:%s\n",errstr);
    }
    printf("exit data : %d\n",*thread_retval);
    printf("回收子线程资源成功\n");
    //让主线程退出
    pthread_exit(NULL);

    return 0;
}

线程分离

#include <pthread.h>

int pthread_detach(pthread_t thread);

功能：分离一个线程，被分离的线程在终止的时候会自动释放资源返回给系统

1、不能多次分离，会产生不可预料的行为

2、不能用pthread_join()连接一个已经分离的线程，操作会报错

参数：需要分离的线程ID

返回值：

成功：0

失败：返回错误号
cpp 复制代码
#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <unistd.h>
void *callback(void *arg)
{
    printf("child thread id : %ld\n",pthread_self());
    return NULL;
}

int main()
{
    pthread_t tid;
    int ret = pthread_create(&tid,NULL,callback,NULL);
    if(ret != 0)
    {
        char *errstr = strerror(ret);
        printf("error1:%s\n",errstr);
    }
    //输出主线程和子线程的id
    printf("tid : %ld,main thread id:%ld\n",tid,pthread_self());

    //设置子线程分离,子线程分离后，子线程结束时对应的资源就不需要主线程释放
    ret = pthread_detach(tid);
    if(ret != 0)
    {
        char *errstr = strerror(ret);
        printf("error2:%s\n",errstr);
    }

    pthread_exit(NULL);
    return 0;
}

线程取消

#include <pthread.h>

int pthread_cancel(pthread_t thread);

功能：取消线程，让线程终止

取消线程可以终止某个线程的运行

但是并不是立马终止，而是当子线程执行到一个取消点，线程才会终止

取消点：系统规定好的一些系统调用，我们可以粗略的理解为从用户区到内核区

的切换，这个位置称为取消点
cpp 复制代码
#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <unistd.h>
void *callback(void *arg)
{
    printf("child thread id : %ld\n",pthread_self());
    
    for(int i = 0;i < 5;i ++)
    {
        printf("child :%d\n",i);
    }
    return NULL;
}

int main()
{
    pthread_t tid;
    int ret = pthread_create(&tid,NULL,callback,NULL);
    if(ret != 0)
    {
        char *errstr = strerror(ret);
        printf("error1:%s\n",errstr);
    }
    //输出主线程和子线程的id
    printf("tid : %ld,main thread id:%ld\n",tid,pthread_self());

    //取消线程
    pthread_cancel(tid);

    for(int i = 0;i < 5;i ++)
    {
        printf("%d\n",i);
    }

    pthread_exit(NULL);
    return 0;
}

线程属性

int pthread_attr_init(pthread_attr_t *attr);

-初始化线程属性变量

int pthread_attr_destroy(pthread_attr_t *attr);

释放线程属性的资源

int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate);

获取线程分离的状态属性

int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);

设置线程分离的状态属性

cpp 复制代码

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

void *callback(void *arg)
{
    printf("child thread id : %ld\n",pthread_self());
    return NULL;
}

int main()
{
    //创建一个线程属性变量
    pthread_attr_t attr;
    //初始化属性变量
    pthread_attr_init(&attr);
    //设置属性
    pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);

    pthread_t tid;
    int ret = pthread_create(&tid,&attr,callback,NULL);
    if(ret != 0)
    {
        char *errstr = strerror(ret);
        printf("error1:%s\n",errstr);
    }
    //输出主线程和子线程的id
    printf("tid : %ld,main thread id:%ld\n",tid,pthread_self());

    //获取线程栈的大小
    size_t size;
    pthread_attr_getstacksize(&attr,&size);
    printf("Thread stack size:%ld\n",size);
    //释放线程属性资源
    pthread_attr_destroy(&attr);
    pthread_exit(NULL);
    return 0;
}

线程同步

互斥量/互斥锁

互斥量的类型 pthread_mutex_t

◼ int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr);

功能：初始化互斥量

参数：

-mutex：需要初始化的互斥量变量

-attr：互斥量相关的属性，NULL

restrict：C语言的修饰符，被修饰的指针，不能由另外的一个指针进行操作

◼ int pthread_mutex_destroy(pthread_mutex_t *mutex);

功能：释放互斥量的资源

◼ int pthread_mutex_lock(pthread_mutex_t *mutex);

功能：加锁，如果有一个线程加锁，那么其他线程只能阻塞等待

◼ int pthread_mutex_trylock(pthread_mutex_t *mutex);

功能：尝试加锁，如果加锁失败，不会阻塞，会直接返回

◼ int pthread_mutex_unlock(pthread_mutex_t *mutex);

功能：解锁

死锁

多线程多锁的情况

cpp 复制代码

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
//创建2个互斥量
pthread_mutex_t mutex1,mutex2;
void *worka(void *arg)
{
    pthread_mutex_lock(&mutex1);
    sleep(1);
    pthread_mutex_lock(&mutex2);

    printf("worka...\n");

    pthread_mutex_unlock(&mutex2);
    pthread_mutex_unlock(&mutex1);
    return NULL;
}

void *workb(void *arg)
{
    pthread_mutex_lock(&mutex2);
    sleep(1);
    pthread_mutex_lock(&mutex1);

    printf("workb...\n");

    pthread_mutex_unlock(&mutex1);
    pthread_mutex_unlock(&mutex2);
    return NULL;
}



int main()
{
    //初始化互斥量
    pthread_mutex_init(&mutex1,NULL);
    pthread_mutex_init(&mutex2,NULL);

    //创建2个子线程
    pthread_t tid1,tid2;
    pthread_create(&tid1,NULL,worka,NULL);
    pthread_create(&tid2,NULL,workb,NULL);

    //回收子线程资源
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);

    //释放互斥量资源
    pthread_mutex_destroy(&mutex1);
    pthread_mutex_destroy(&mutex2);
    return 0;
}

读写锁

◼ 读写锁的类型 pthread_rwlock_t

◼ int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,

const pthread_rwlockattr_t *restrict attr);

◼ int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

◼ int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);

◼ int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);

◼ int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);

◼ int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);

◼ int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

cpp 复制代码

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

/*
    案例：8个线程操作同一个全局变量
    3个线程不定时写这个全局变量，5个线程不定时的读这个全局变量
*/
int num = 1;
pthread_rwlock_t rwlock;
void *writeNum(void *arg)
{
    while (1)
    {
        pthread_rwlock_wrlock(&rwlock);
        num ++;
        printf("++write,tid:%ld,num:%d\n",pthread_self(),num);
        pthread_rwlock_unlock(&rwlock);
        usleep(100);
    }
    return NULL;
}
void *readNum(void *arg)
{
    while(1)
    {
        pthread_rwlock_rdlock(&rwlock);
        printf("==read,tid:%ld,num : %d\n",pthread_self(),num);
        pthread_rwlock_unlock(&rwlock);
        usleep(100);
    }
    return NULL;
}

int main()
{
    pthread_rwlock_init(&rwlock,NULL);
    //创建3个写线程，5个读线程
    pthread_t wtids[3],rtids[5];
    for(int i = 0;i < 3;i ++)
    {
        pthread_create(&wtids[i],NULL,writeNum,NULL);
    }
    for(int i = 0;i < 5;i ++)
    {
        pthread_create(&rtids[i],NULL,readNum,NULL);
    }
    //设置线程分离
    for(int i = 0;i < 3;i ++)
    {
        pthread_detach(wtids[i]);
    }
    for(int i = 0;i < 5;i ++)
    {
        pthread_detach(rtids[i]);
    }
    pthread_exit(NULL);
    pthread_rwlock_destroy(&rwlock);
    return 0;
}

生产者消费者模型

条件变量

与互斥锁一起用

◼ 条件变量的类型 pthread_cond_t

◼ int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);

功能：初始化条件变量

◼ int pthread_cond_destroy(pthread_cond_t *cond);

功能：释放条件变量

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

功能：阻塞函数，调用该函数线程会阻塞

当这个函数调用阻塞的时候，会对互斥锁进程解锁，当不阻塞的时候，继续向下执行，会重新加锁

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

功能：设置等待多少时间，调用这个函数，线程会阻塞直到指定时间结束

◼ int pthread_cond_signal(pthread_cond_t *cond);

功能：唤醒一个或者多个等待线程

◼ int pthread_cond_broadcast(pthread_cond_t *cond);

功能：唤醒所有等待的线程
cpp 复制代码
/*
    生产者消费者模型（粗略的版本）
*/

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

struct Node{
    int num;
    struct Node *next;
};

pthread_mutex_t mutex;
pthread_cond_t cond;
//头结点
struct Node *head = NULL;
void *producer(void *arg)
{
    //不断创建新的结点，添加到链表中
    while(1)
    {
        pthread_mutex_lock(&mutex);
        struct Node *newNode = (struct Node*)malloc(sizeof(struct Node));
        newNode->next = head;
        head = newNode;
        newNode->num = rand() % 1000;
        printf("add node,num:%d,tid:%ld\n",newNode->num,pthread_self());
        //只要生产一个就通知消费者消费
        pthread_cond_signal(&cond);
        pthread_mutex_unlock(&mutex);
        usleep(100);
    }
    return NULL;
}
void *customer(void *arg)
{
    while(1)
    {
        pthread_mutex_lock(&mutex);
        //判断是否有数据
        if(head != NULL)
        {
            //保存头结点的指针
            struct Node *tmp = head;
            head = head->next;
            printf("del node,num : %d,tid :%ld\n",tmp->num,pthread_self());
            free(tmp);
            pthread_mutex_unlock(&mutex);
            usleep(100);
        }
        else{
            //没有数据需要等待
            pthread_cond_wait(&cond,&mutex);
            pthread_mutex_unlock(&mutex);
        }
        
    }
    return NULL;
}
int main()
{
    //创建5个生产者线程和5个消费者线程
    pthread_mutex_init(&mutex,NULL);
    pthread_cond_init(&cond,NULL);
    pthread_t ptids[5],ctids[5];
    for(int i = 0;i < 5;i ++)
    {
        pthread_create(&ptids[i],NULL,producer,NULL);
        pthread_create(&ctids[i],NULL,customer,NULL);
    }
    for(int i = 0;i < 5;i ++)
    {
        pthread_detach(ptids[i]);
        pthread_detach(ctids[i]);
    }

    while(1)
    {
        sleep(10);
    }

    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);
    pthread_exit(NULL);
    
    return 0;
}

信号量

#include <semaphore.h>

◼ 信号量的类型 sem_t

◼ int sem_init(sem_t *sem, int pshared, unsigned int value);

功能：初始化信号量

参数：

sem：信号量

psshared：0：用在线程间非0：用在进程间

value：信号量中的值

◼ int sem_destroy(sem_t *sem);

功能：释放资源

◼ int sem_wait(sem_t *sem);

功能：对信号量加锁，调用一次对这个信号量的值-1，如果值为0，就阻塞

◼ int sem_trywait(sem_t *sem);

功能：尝试等待

◼ int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);

◼ int sem_post(sem_t *sem);

功能：对信号量解锁，调用一次对信号量的值+1

◼ int sem_getvalue(sem_t *sem, int *sval);

cpp 复制代码

/*
    生产者消费者模型（粗略的版本）
*/

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

struct Node{
    int num;
    struct Node *next;
};

pthread_mutex_t mutex;
//创建两个信号量
sem_t psem;
sem_t csem;

//头结点
struct Node *head = NULL;
void *producer(void *arg)
{
    //不断创建新的结点，添加到链表中
    while(1)
    {
        sem_wait(&psem);
        pthread_mutex_lock(&mutex);
        struct Node *newNode = (struct Node*)malloc(sizeof(struct Node));
        newNode->next = head;
        head = newNode;
        newNode->num = rand() % 1000;
        printf("add node,num:%d,tid:%ld\n",newNode->num,pthread_self());
        pthread_mutex_unlock(&mutex);
        sem_post(&csem);
        usleep(100);
    }
    return NULL;
}
void *customer(void *arg)
{
    while(1)
    {
        sem_wait(&csem);
        pthread_mutex_lock(&mutex);
        //判断是否有数据
        //保存头结点的指针
        struct Node *tmp = head;
        head = head->next;
        printf("del node,num : %d,tid :%ld\n",tmp->num,pthread_self());
        free(tmp);
        pthread_mutex_unlock(&mutex);
        sem_post(&psem);
        usleep(100);
   
    }
    return NULL;
}
int main()
{
    pthread_mutex_init(&mutex,NULL);
    sem_init(&psem,0,8);
    sem_init(&csem,0,0);
    //创建5个生产者线程和5个消费者线程
    pthread_mutex_init(&mutex,NULL);
    pthread_t ptids[5],ctids[5];
    for(int i = 0;i < 5;i ++)
    {
        pthread_create(&ptids[i],NULL,producer,NULL);
        pthread_create(&ctids[i],NULL,customer,NULL);
    }
    for(int i = 0;i < 5;i ++)
    {
        pthread_detach(ptids[i]);
        pthread_detach(ctids[i]);
    }

    while(1)
    {
        sleep(10);
    }

    pthread_mutex_destroy(&mutex);
    pthread_exit(NULL);
    
    return 0;
}