Linux 多线程编程（线程、互斥锁、条件变量）

one goto one

已于 2022-03-27 21:53:31 修改

阅读量253

点赞数

分类专栏： linux应用文章标签：嵌入式

于 2021-06-21 19:14:42 首次发布

本文链接：https://blog.csdn.net/weixin_54178481/article/details/116174610

版权

linux应用专栏收录该内容

20 篇文章 0 订阅

订阅专栏

linux多线程编程

一、多线程的优点

多线程程序作为一种多任务、并发的工作方式，有以下的优点：

提高应用程序响应。这对图形界面的程序尤其有意义，当一个操作耗时很长时，整个系统都会等待这个操作，此时程序不会响应键盘、鼠标、菜单的操作，而使用多线程技术，将耗时长的操作（time consuming）置于一个新的线程，可以避免这种尴尬的情况。
使多CPU系统更加有效。操作系统会保证当线程数不大于CPU数目时，不同的线程运行于不同的CPU上。
改善程序结构。一个既长又复杂的进程可以考虑分为多个线程，成为几个独立或半独立的运行部分，这样的程序会利于理解和修改。

二、进程与线程

多线程是一种非常"节俭"的多任务操作方式。Linux系统下，启动一个新的进程必须分配给它独立的地址空间，建立众多的数据表来维护它的代码段、堆栈段和数据段，这是一种"昂贵"的多任务工作方式。而运行于一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享大部分数据，启动一个线程所花费的空间远远小于启动一个进程所花费的空间，而且，线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。据统计，总的说来，一个进程的开销大约是一个线程开销的30倍左右，当然，在具体的系统上，这个数据可能会有较大的区别。
使用多线程的理由之二是线程间方便的通信机制。对不同进程来说，它们具有独立的数据空间，要进行数据的传递只能通过通信的方式进行，这种方式不仅费时，而且很不方便。线程则不然，由于同一进程下的线程之间共享数据空间，所以一个线程的数据可以直接为其它线程所用，这不仅快捷，而且方便。当然，数据的共享也带来其他一些问题，有的变量不能同时被两个线程所修改，有的子程序中声明为static的数据更有可能给多线程程序带来灾难性的打击，这些正是编写多线程程序时最需要注意的地方。
进程有自己独立的地址空间，而线程有自己独立的堆栈和局部变量，但是没有独立的地址空间。一个进程崩溃后，其他进程不会受影响，而一个线程崩溃的后果就是整个进程都崩溃了。所以多进程程序比多线程程序健壮，但是进程间进行切换消耗资源巨大效率低，对于一些要求同时进行又要共享某些变量的并发操作，只能用线程，不能用进程。

三、Linux多线程API

使用多线程注意：

应避免在多线程模型中调用fork，除非立即exec，子进程中只有调用fork的线程存在，其他线程均pthread_exit
信号的复杂语义很难和多线程共存，应避免多线程引入信号机制
ps -Lf 进程id 指令查看线程号

Linux多线程基本概念：线程、互斥锁、条件

1. 线程

①线程创建

#include <pthread.h>

int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg)
返回：成功返回0，否则返回错误编号

参数：①新线程id	②线程属性（NULL 默认属性）	③动作函数	④向动作函数传递的参数（多个参数使用结构体传递）

由于线程创建需要进行内核空间的切换需要花费的时间很长，如果参数4采用地址传递，回调函数访问参数4的值的时候有可能已经被主线程修改了。为了保证访问的参数4值不变可以使用值传递
int i;
地址传递：(void)&i
值传递：（void*)i

②线程退出

#include <pthread.h>

void pthread_exit(void *retval)
无返回值
参数： 用于存储当前线程的信息。其他线程可以调用pthread_join()访问这个指针

③线程等待

#include <pthread.h>

int pthread_join(pthread_t thread, void **retval)
返回： 成功返回 0	失败返回错误编号
参数： ①等待的线程id		②访问pthread_exit() retval指针的指针

④线程分离

线程分离就是当线程被设置为分离状态后，线程结束时，它的资源会被系统自动回收不需要在其他的线程中对其进行pthread_join()操作。若为非脱离状态又不对其进行pthread_join操作那么这个进程结束后就会变成僵尸线程。僵尸进程太多占用过多系统资源就会导致创建线程失败。

使用pthread_join()回收被pthread_detach()的线程返回-1

#include <pthread.h>

int pthread_detach(pthread_t thread)
返回： 成功返回 0 失败返回错误编号
通常使用于让自己脱离的线程使用

⑤线程的ID获取与比较

#include <pthread.h>

pthread_t pthread_self(void)
返回： 100%成功返回线程id

移植操作中，我们不能简单地把线程ID当作整数来处理，因为不同系统对线程ID的定义可能不一样

#include <pthread.h>

int pthread_equal(pthread_t t1, pthread_t t2)
100%成功：相等返回非零数	不等返回 0

⑥线程取消

#include <pthread.h>

int pthread_cancel(pthread_t thread);
成功：0  失败：errno
杀死一个线程需要到达取消点，如果线程没有到达取消点则pthread_cancel()无效
我们可以在线程中手动添加一个取消点，使用pthread_testcancel()

⑦线程检查错误返回

perror() 用于进程检查错误返回，不再适用于线程
线程检查错误返回方式：

if (ret) {
	fprintf(stderr, "xxx error:%s\n", strerror(ret));
	exit(-1);
}

2. 互斥锁

互斥量本质是一把锁，通过锁将共享资源的访问变成互斥操作。A线程加锁后，其他想要对互斥量加锁的线程被阻塞到A线程解锁后才变为可运行状态，第一个变为可运行状态的线程可以对互斥量加锁，剩余的线程继续保持阻塞状态。这种方式下每次只能有一个线程可以向前运行。

①创建与销毁锁

#include <pthread.h>

pthread_mutex_t mutex；//创建锁
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);//初始化锁
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;//静态初始
参数： ①锁变量 	②锁的属性（默认属性初始化互斥量  设置为NULL）

int pthread_mutex_destroy(pthread_mutex_t *mutex)    
返回：若成功返回0，否则返回错误编号

②加锁解锁

#include <pthread.h>

int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);	//若互斥量被其他的线程加锁中，则失败立即返回EBUSY

int pthread_mutex_unlock(pthread_mutex_t *mutex)
返回：若成功返回0，否则返回错误编号

3. 条件

一种可以让线程休眠等待某个条件，条件满足唤醒线程去检测这个条件是否真的满足的机制。整个过程等待的不是条件变量设定的那个参数值，而是应用程序自己定义的那个条件，条件变量只是一种唤醒等待线程的机制，条件变量与互斥量一起使用时，允许线程以无竞争的方式等待特定的条件发生

①创建及销毁条件变量

#include <pthread.h>
pthread_cond_t cond;//创建条件变量
int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);//动态初始化条件变量
pthread_cond_t cond = PTHREAD_COND_INITIALIZER; //使用宏静态初始化条件变量
参数： ①条件变量	②条件变量属性（默认属性NULL）

int pthread_cond_destroy(pthread_cond_t *cond)
返回： 若成功返回0，否则返回错误编号

②等待

pthread_cond_wait执行过程：unlock—wait—lock

#include <pthread.h>

int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime);	//abstime用于指定时
返回： 若成功返回0，否则返回错误编号

③触发与广播

触发与广播都是通知其他的线程条件已满足，区别在于触发是一对一，广播是一对多
注意必须要在条件满足后才进行触发或广播否则无效

#include <pthread.h>

int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond)
返回： 若成功返回0，否则返回错误编号

四、示例

① demo1 创建一个线程

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

void *func1(void *num)
{
        static int ret = 100;

        printf("func1Id = %ld   num = %d\n", pthread_self(), *((int*)num));
        pthread_exit((void*)(&ret));
}

int main()
{
        int ret = 0;
        pthread_t t1;
        int num = 100;
        int *pret = NULL;

        ret = pthread_create(&t1, NULL, func1, (void*)(&num));
        if (!ret) {
                printf("mainId = %ld  func1 create success\n", pthread_self());
        }
        pthread_join(t1, (void **)(&pret));
        printf("ret of t1 = %d\n", (*(int*)pret));

        return 0;
}

运行结果

mainId = 140685628561152  func1 create success
func1Id = 140685620274944   num = 100
ret of t1 = 100

② demo2 使用互斥锁

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

int data = 0;
pthread_mutex_t mutex1;

void *func1(void *arg)
{
        int n = 3;

        pthread_mutex_lock(&mutex1);
        while(n--) {
                printf("func1: data = %d\n", data++);
                sleep(1);
        }
        pthread_mutex_unlock(&mutex1);
}

void *func2(void *arg)
{
        int n = 3;

        pthread_mutex_lock(&mutex1);
        while(n--) {
                        printf("func2: data = %d\n", data++);
                        sleep(1);
        }
        pthread_mutex_unlock(&mutex1);
}

int main()
{
        int ret = 0;
        pthread_t t1;
        pthread_t t2;

        pthread_mutex_init(&mutex1, NULL);
        pthread_create(&t1, NULL, func1, NULL);
        pthread_create(&t2, NULL, func2, NULL);

        pthread_join(t1, NULL);
        pthread_join(t2, NULL);
        pthread_mutex_destroy(&mutex1);

        return 0;
}

运行结果

可见线程一执行完毕退出后线程二而才开始运行，说明使用了互斥锁共享资源只能由一个线程访问并在结束后其他线程才能进行访问，若未使用互斥锁则共享资源的访问由调度机制决定（线程之间交替访问共享资源）

func1: data = 0
func1: data = 1
func1: data = 2
func2: data = 3
func2: data = 4
func2: data = 5

③demo3 使用条件

条件data = 3，线程一等待线程二，当条件满足时线程二对线程一触发，线程二退出

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

int data = 0;
pthread_mutex_t mutex1;
pthread_cond_t  cond1;

void *func1(void *arg)
{
        int n = 3;

        pthread_cond_wait(&cond1, &mutex1);
        while(n--) {
                printf("func1: data = %d\n", data++);
                sleep(1);
        }
}

void *func2(void *arg)
{
        while(1) {
                printf("func2: data = %d\n", data++);
                sleep(1);
                if (data == 3) {
                        pthread_cond_signal(&cond1);
                        pthread_exit(NULL);
                }
        }
}

int main()
{
        int ret = 0;
        pthread_t t1;
        pthread_t t2;

        pthread_mutex_init(&mutex1, NULL);
        pthread_cond_init(&cond1, NULL);
        pthread_create(&t1, NULL, func1, NULL);
        pthread_create(&t2, NULL, func2, NULL);

        pthread_join(t1, NULL);
        pthread_join(t2, NULL);
        pthread_mutex_destroy(&mutex1);
        pthread_cond_destroy(&cond1);

        return 0;
}

运行结果

func2: data = 0
func2: data = 1
func2: data = 2
func1: data = 3
func1: data = 4
func1: data = 5

one goto one

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录