LINUX线程API、互斥锁、条件变量

最新推荐文章于 2023-04-17 19:44:44 发布

大喊一声：哪里跑！

最新推荐文章于 2023-04-17 19:44:44 发布

阅读量217

点赞数

分类专栏： LINUX

本文链接：https://blog.csdn.net/qq_44370382/article/details/107897907

版权

LINUX 专栏收录该内容

9 篇文章 1 订阅

订阅专栏

修改自博文https://www.cnblogs.com/xiehongfeng100/p/4620852.html
生产者消费者博文：
Linux下实现多线程的生产者消费者问题

生产者消费者编程实现-线程池+信号量

Linux多线程──生产者消费者

文章目录

一、线程与进程

典型的UNIX/Linux进程可以看成只有一个控制线程：一个进程在同一时刻只做一件事情。有了多个控制线程后，在程序设计时可以把进程设计成在同一时刻做不止一件事，每个线程各自处理独立的任务。

“进程——资源分配的最小单位，线程——程序执行的最小单位”

进程是程序执行时的一个实例，是担当分配系统资源（CPU时间、内存等）的基本单位。在面向线程设计的系统中，进程本身不是基本运行单位，而是线程的容器。程序本身只是指令、数据及其组织形式的描述，进程才是程序（那些指令和数据）的真正运行实例。

线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。线程包含了表示进程内执行环境必须的信息，其中包括进程中表示线程的线程ID、一组寄存器值、栈、调度优先级和策略、信号屏蔽字、errno常量以及线程私有数据。进程的所有信息对该进程的所有线程都是共享的，包括可执行的程序文本、程序的全局内存和堆内存、栈以及文件描述符。在Unix和类Unix操作系统中线程也被称为轻量级进程（lightweight processes），但轻量级进程更多指的是内核线程（kernel thread），而把用户线程（user thread）称为线程。

进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。

从函数调用上来说，进程创建使用fork()操作；线程创建使用clone()操作

多线程优点：

和进程相比，它是一种非常"节俭"的多任务操作方式。

线程间方便的通信机制。

二、线程API

多线程开发在 Linux 平台上已经有成熟的 pthread 库支持。其涉及的多线程开发的最基本概念主要包含三点：线程，互斥锁，条件。
线程操作又分线程的创建，退出，等待 3 种。
互斥锁则包括 4 种操作，分别是创建，销毁，加锁和解锁。
条件操作有 5 种操作：创建，销毁，触发，广播和等待。
其他的一些线程扩展概念，如信号灯等，都可以通过上面的三个基本元素的基本操作封装出来。详细请见下表：在这里插入图片描述

三、线程操作API

1. 线程创建pthread_create

#include <pthread.h>
int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);

// 返回：若成功返回0，否则返回错误编号

当pthread_create成功返回时，由tidp指向的内存单元被设置为新创建线程的线程ID。

attr参数用于定制各种不同的线程属性，暂可以把它设置为NULL，以创建默认属性的线程。
(*start_rtn)(void *)函数指针，void *(*start_rtn)(void *)指向函数指针的指针

新创建的线程从start_rtn函数的地址开始运行，该函数只有一个无类型指针参数arg。如果需要向start_rtn函数传递的参数不止一个，那么需要把这些参数放到一个结构中，然后把这个结构的地址作为arg参数传入。（参考demo代码）给新创建的线程传递参数，不传参写为NULL

2. 线程退出pthread_exit

单个线程可以通过以下三种方式退出，在不终止整个进程的情况下停止它的控制流：

1）线程只是从启动例程中返回，返回值是线程的退出码。

2）线程可以被同一进程中的其他线程取消。

3）线程调用pthread_exit：

#include <pthread.h>
int pthread_exit(void *rval_ptr);

rval_ptr是一个无类型指针，与传给启动例程的单个参数类似。进程中的其他线程可以通过调用pthread_join函数访问到这个指针。

3. 线程等待pthread_join

#include <pthread.h>
int pthread_join(pthread_t thread, void **rval_ptr);

// 返回：若成功返回0，否则返回错误编号
　　调用这个函数的线程将一直阻塞，直到指定的线程调用pthread_exit、从启动例程中返回或者被取消。如果例程只是从它的启动例程返回i，rval_ptr将包含返回码。如果线程被取消，由rval_ptr指定的内存单元就置为PTHREAD_CANCELED。

可以通过调用pthread_join自动把线程置于分离状态，这样资源就可以恢复。如果线程已经处于分离状态，pthread_join调用就会失败，返回EINVAL。

如果对线程的返回值不感兴趣，可以把rval_ptr置为NULL。在这种情况下，调用pthread_join函数将等待指定的线程终止，但并不获得线程的终止状态。

4. 线程ID获取pthread_self及比较

#include <pthread.h>
pthread_t pthread_self(void);

// 返回：调用线程的ID 　　ubuntn下，是unsigned long类型

对于线程ID比较，为了可移植操作，我们不能简单地把线程ID当作整数来处理，因为不同系统对线程ID的定义可能不一样。我们应该要用下边的函数：

#include <pthread.h>
int pthread_equal(pthread_t tid1, pthread_t tid2);

// 返回：若相等则返回非0值，否则返回0

5. 线程脱离

#include <pthread.h>
int pthread_detach(pthread_t thread);

一个线程或者是可汇合（joinable，默认值），或者是脱离的（detached）。当一个可汇合的线程终止时，它的线程ID和退出状态将留存到另一个线程对它调用pthread_join。脱离的线程却像守护进程，当它们终止时，所有相关的资源都被释放，我们不能等待它们终止。如果一个线程需要知道另一线程什么时候终止，那就最好保持第二个线程的可汇合状态。
　　pthread_detach函数把指定的线程转变为脱离状态。

// 返回：若成功返回0，否则返回错误编号
　　本函数通常由想让自己脱离的线程使用，就如以下语句：pthread_detach(pthread_self());

四、demo线程创建

typedef和#define的用法与区别
#define 标识符字符串
　　其中的“#”表示这是一条预处理命令。凡是以“#”开头的均为预处理命令。“define”为宏定义命令。“标识符”为所定义的宏名。“字符串”可以是常数、表达式、格式串等。
static定义
c语言中static的作用(精辟分析)

#include<sys/types.h>
#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<errno.h> //perror
#define uint unsigned long
void *thread1(void *arg)
{
		//static 使子函数退出后定义的变量不会消失
//      static int ret = 10;  //返回可以是整型也可以是字符 
        static char *p = "tid1 is run quit";//返回字符串
        printf("this is thread1:the process is %ld,the threadis %ld\n",(uint)getpid(),(uint)pthread_self());
        printf("data is %d\n",*((int *)arg));
        //arg是一个无类型指针，所以要转换成int型指针，再取里边的整型变量

//      pthread_exit((void *)&ret);//返回整数
        pthread_exit((void *)p);//返回字符串

}

int main()
{
        int ret;
        int data = 100;
//      int *pret; 返回整数
        char *pret = NULL;//返回字符串，创建一个空间，用于接收线程退出返回的信息
        pthread_t tid1;
        printf("enter the main function\n");

        ret = pthread_create(&tid1,NULL,thread1,(void *)&data);//&tid1指针
        //第4个参数，传递数据，是一个无类型指针，所以要先取数据的地址得到一个指针，在（void *）转换为无类型指针
        //如果传递的数据较多，可以将参数放在一个结构中
        if(ret == 0)//创建成功返回0
        {
                printf("creat thread1 success\n");
        }else
        {
                perror("creat failed");
        }
		//（unit）pthread_self()获取线程ID
        printf("this is main thread:the process is %ld,the thread is %ld\n",(uint)getpid(),(uint)pthread_self());
        printf("leave the main thread\n");

        pthread_join(tid1,(void **)&pret);//void **二级指针，所以要&
                                        //线程返回的信息，返回放到pret空间里
//      printf("main:tid1 quit %d\n",*pret);//返回整数
        printf("main:tid1 quit %s\n",pret);
        return 0;
}

五、互斥锁及相关API mutex

对于多线程程序来说，我们往往需要对这些多线程进行同步。同步（synchronization）是指在一定的时间内只允许某一个线程访问某个资源。而在此时间内，不允许其它的线程访问该资源。我们可以通过互斥锁（mutex），条件变量（condition variable）和读写锁（reader-writer lock）来同步资源。

互斥量（mutex）从本质上来说是一把锁，在访问共享资源前对互斥量进行加锁，在访问完成后释放互斥量上的锁。对互斥量进行加锁后，任何其他试图再次对互斥量加锁的线程将会被阻塞直到当前线程释放该互斥锁。如果释放互斥锁时有多个线程阻塞，所有在该互斥锁上的阻塞线程都会变成可运行状态，第一个变为可运行状态的线程可以对互斥量加锁，其他线程将会看到互斥锁依然被锁住，只能回去等待它重新变为可用。在这种方式下，每次只有一个线程可以向前运行。
pthread_mutex_t mutex; 定义互斥量（一般定义为全局变量）

初始化：互斥变量用pthread_mutex_t数据类型表示。在使用互斥变量前必须对它进行初始化
初始化有两种方式（条件变量的初始化类似）

调用宏 PTHREAD_MUTEX_INITIALIZER
把它置为常量PTHREAD_MUTEX_INITIALIZER（只对静态分配的互斥量）
demo :
通过调用pthread_mutex_init创建函数进行初始化。如果动态地分配互斥量（例如通过调用malloc函数），那么在释放内存前需要调用pthread_mutex_destroy销毁

1. 创建及销毁互斥锁

#include <pthread.h>
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
int pthread_mutex_destroy(pthread_mutex_t *mutex);//*mutex
// 返回：若成功返回0，否则返回错误编号

                  pthread_mutex_init(&mutex,NULL); //创建互斥序锁及初始化
                  pthread_mutex_destroy(&mutex);  //销毁互斥锁

要用默认的属性初始化互斥量，只需把attr设置为NULL。　
pthread_mutex_init(&mutex,NULL);

2. 加锁及解锁

#include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
// 返回：若成功返回0，否则返回错误编号

           pthread_mutex_lock(&mutex);   //加锁  
           pthread_mutex_lock(&mutex);   //解锁

如果线程不希望被阻塞，它可以使用pthread_mutex_trylock尝试对互斥量进行加锁。如果调用pthread_mutex_trylock时互斥量处于未锁住状态，那么pthread_mutex_trylock将锁住互斥量，不会出现阻塞并返回0，否则pthread_mutex_trylock就会失败，不能锁住互斥量，而返回EBUSY。

3. 加锁解锁demo

创建两个线程，不进行加锁操作的情况下，两个线程会发生竞争，进程1在运行时，进程2就会变成可运行状态进行等待，进程1运行一个操作后，进程2就立刻运行，而非待进程1全部运行结束

void *func1(void *arg)//线程1
{
        int i;
        for(i=0;i<3;i++)
        {

                printf("t1:%ld thread is create\n",(uint)pthread_self());
                printf("t1:param is %d\n",*((int *)arg));
                sleep(1);
        }
        pthread_exit(NULL);
}
void *func2(void *arg)//线程2
{
        int i;
        for(i=0;i<3;i++)
        {

                printf("t2:%ld thread is create\n",(uint)pthread_self());
                printf("t2:param is %d\n",*((int *)arg));
                sleep(1);
        }
        pthread_exit(NULL);

}

运行结果：t2与t1交替打印
在这里插入图片描述
加锁

#include<sys/types.h>
#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<errno.h>
#define uint unsigned long
//互斥变量使用特定的数据类型：pthread_mutex_t
pthread_mutex_t mutex; //声明全局变量 互斥量mutex类型

//互斥量初始化方法一：PTHREAD_MUTEX_INITIALIZER
//pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER 

void *func1(void *arg)
{
        pthread_mutex_lock(&mutex); //加锁
        int i;
        for(i=0;i<3;i++)
        {
                printf("t1:%ld thread is create\n",(uint)pthread_self());
                printf("t1:param is %d\n",*((int *)arg));
                sleep(1);
        }
        pthread_mutex_unlock(&mutex);//解锁
        pthread_exit(NULL);
}
void *func2(void *arg)
{
        pthread_mutex_lock(&mutex);//加锁
        int i;
        for(i=0;i<3;i++)
        {
                printf("t2:%ld thread is create\n",(uint)pthread_self());
                printf("t2:param is %d\n",*((int *)arg));
                sleep(1);
        }
        pthread_mutex_unlock(&mutex);//解锁
        pthread_exit(NULL);

}
int main()
{
        int ret;
        int data = 100;
        pthread_t t1;
        pthread_t t2;
		
		//创建互斥锁  及初始化互斥量，默认NULL
        pthread_mutex_init(&mutex,NULL); 
		
		//创建条件变量 及初始化
		//pthread_cond_init(&cond,NULL);

        //creat func1 func2
        ret = pthread_create(&t1,NULL,func1,(void *)&data);
        if(ret == 0)
        {
                printf("main:creat t1 success\n");
        }
        ret = pthread_create(&t1,NULL,func2,(void *)&data);
        if(ret == 0)
        {
                printf("main:creat t2 success\n");
        }
        //main thread id
        printf("main:thread id:%ld\n",(uint)pthread_self());

        pthread_join(t1,NULL);
        pthread_join(t2,NULL);
		
		//销毁互斥锁
        pthread_mutex_destroy(&mutex);
		
		//销毁条件变量
		//pthread_cond_init(&cond,NULL);


        return 0;
}

在这里插入图片描述
进行加锁及解锁操作后，线程1和线程2就会保持相对稳定。不过先打印线程1或线程2是不一定的

4.死锁

死锁：如果一组进程中的每一个进程都在等待仅由该组进程中的其他进程才能引发的事件，那么该组进程是死锁的。
死锁有单进程死锁：进程A拥有资源1，而它又在请求资源1，而它所请求的资源1必须等待该资源使用完毕得到释放后才可被请求。这样，就陷入了自己的死锁。
还有多进程死锁：有进程A，进程B，进程A拥有资源1，需要请求正在被进程B占有的资源2。而进程B拥有资源2，请求正在被进程A占有的资源1。两个进程都在等待对方释放资源后请求该资源，而相互僵持，陷入死锁。

产生死锁的三个原因：

进程推进顺序不当造成死锁。
竞争不可抢占性资源引起死锁。
竞争可消耗性资源引起死锁。

产生死锁的四个必要条件：

（1）互斥条件：一个资源每次只能被一个进程（线程）使用。
（2）请求与保持条件：一个进程（线程）因请求资源而阻塞时，对已获得的资源保持不放。
（3）不剥夺条件 : 此进程（线程）已获得的资源，在末使用完之前，不能强行剥夺。
（4）循环等待条件 : 多个进程（线程）之间形成一种头尾相接的循环等待资源关系。

死锁的避免方法：

终止（或撤销）进程。终止（或撤销）系统中的一个或多个死锁进程，直至打破循环环路，使系统从死锁状态中解除出来。
抢占资源。从一个或多个进程中抢占足够数量的资源，分配给死锁进程，以打破死锁状态。
最好不用锁。

六. 条件变量及相关API cond

条件变量是线程另一可用的同步机制。条件变量给多个线程提供了一个会合的场所。条件变量与互斥量一起使用时，允许线程以无竞争的方式等待特定的条件发生。

条件本身是由互斥量保护的。线程在改变条件状态前必须首先锁住互斥量，其他线程在获得互斥量之前不会察觉到这种改变，因为必须锁定互斥量以后才能计算条件。

条件变量使用之前必须首先初始化，pthread_cond_t数据类型代表的条件变量可以用两种方式进行初始化

可以把常量PTHREAD_COND_INITIALIZER赋给静态分配的条件变量

但是如果条件变量是动态分配的，可以使用pthread_cond_destroy函数对条件变量进行去除初始化（deinitialize）。

1. 创建及销毁条件变量

#include <pthread.h>
int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);
int pthread_cond_destroy(pthread_cond_t cond);
// 返回：若成功返回0，否则返回错误编号

除非需要创建一个非默认属性的条件变量，否则pthread_cont_init函数的attr参数可以设置为NULL。

2. 等待

#include <pthread.h>
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, cond struct timespec *restrict timeout);
// 返回：若成功返回0，否则返回错误编号

pthread_cond_wait等待条件变为真。如果在给定的时间内条件不能满足，那么会生成一个代表一个出错码的返回变量。传递给pthread_cond_wait的互斥量对条件进行保护，调用者把锁住的互斥量传给函数。函数把调用线程放到等待条件的线程列表上，然后对互斥量解锁，这两个操作都是原子操作。这样就关闭了条件检查和线程进入休眠状态等待条件改变这两个操作之间的时间通道，这样线程就不会错过条件的任何变化。pthread_cond_wait返回时，互斥量再次被锁住。

pthread_cond_timedwait函数的工作方式与pthread_cond_wait函数类似，只是多了一个timeout。timeout指定了等待的时间，它是通过timespec结构指定。

3. 触发

#include <pthread.h>//（即广播）
int pthread_cond_signal(pthread_cond_t cond);
int pthread_cond_broadcast(pthread_cond_t cond);
// 返回：若成功返回0，否则返回错误编号

这两个函数可以用于通知线程条件已经满足。即广播
pthread_cond_signal函数将唤醒等待该条件的某个线程
pthread_cond_broadcast函数将唤醒等待该条件的所有进程

注意一定要在改变条件状态以后再给线程发信号。

4.demo条件变量

两个线程的执行，只采取互斥锁的情况下两个线程运行的先后是不确定的。为了确保在全局变量g_data等于3时，会执行线程1。所以对线程2进行加锁，即使先运行线程1，当线程1运行1次后会转为运行线程2，在线程2中进行对g_data++判断当等于3时，线程2会触发会触发线程1的等待，转到线程1运行，线程1执行1次后又会被线程2强先运行

#include<sys/types.h>
#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<errno.h>
#define uint unsigned long
int g_data = 0;

pthread_mutex_t mutex;//声明全局变量 互斥量mutex类型
//互斥量初始化方法一：PTHREAD_MUTEX_INITIALIZER
//pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER 

//条件变变量使用特定的数据类型：pthread_mutex_t
pthread_cond_t cond; //声明cond 
//条件变量初始化方法一：PTHREAD_COND_INITIALIZER
//pthread_cond_t mutex = PTHREAD_COND_INITIALIZER 
void *func1(void *arg)
{
        printf("t1:%ld thread is create\n",(uint)pthread_self());
        printf("t1:data is %d\n",*((int *)arg));

        while(1)
        {
                pthread_cond_wait(&cond,&mutex);  //等待  等待触发
                printf("t1:===================\n");
                printf("t1:%d\n",g_data);
                g_data = 0; //重新将g_data=0
                sleep(1);
                
                static int cnt = 0;
                if(cnt++ == 4)
                {
                        exit(0);//运行5次退出程序
                }
        }
}
void *func2(void *arg)
{
        printf("t2:%ld thread is create\n",(uint)pthread_self());
        printf("t2:data is %d\n",*((int *)arg));

        while(1)
        {
                printf("t2: %d\n",g_data);
                pthread_mutex_lock(&mutex);//加锁
                g_data++;
                if(g_data == 3)
                {
                        pthread_cond_signal(&cond); //触发
                }
                pthread_mutex_unlock(&mutex)；//解锁
                sleep(1);
        }
}
main函数部分与互斥锁demo相同，把注释掉的条件变量的创建及注销接触即可
 	    //创建条件变量 及初始化
		pthread_cond_init(&cond,NULL);
		//注销条件变量
        pthread_cond_destroy(&cond);