linux之pthread_join函数

p t h r e a d _ j o i n pthread\_join pthread_join函数简介

p t h r e a d _ j o i n pthread\_join pthread_join函数可以用于等待一个指定线程的结束,并且收集该线程的返回值(如果有返回值的话)。


下面是 p t h r e a d _ j o i n pthread\_join pthread_join函数的语法:

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

1. t h r e a d 1.thread 1.thread:要等待结束的线程的标识符。
2. r e t v a l 2.retval 2.retval:用于存储线程返回值的指针。如果该线程没有返回值,则该参数可以设置为 N U L L NULL NULL
调用 p t h r e a d _ j o i n pthread\_join pthread_join函数会阻塞当前线程,直到指定的线程结束为止。


p t h r e a d _ j o i n pthread\_join pthread_join函数特点

p h t r e a d _ j o i n phtread\_join phtread_join函数的第2个参数为 v o i d ∗ ∗ void** void ,为二重指针,接收的是线程函数中 p t h r e a d _ e x i t ( v o i d ∗ a r g ) ; pthread\_exit(void* arg); pthread_exit(voidarg);的参数 或者 或者 或者 r e t u r n return return 的值,可以用来查看 p t h r e a d _ e x i t pthread\_exit pthread_exit传递的参数(如果不关心退出状态, p h t r e a d _ j o i n phtread\_join phtread_join的这个参数可以置空,即 p h t r e a d _ j o i n ( t i d , N U L L ) phtread\_join(tid,NULL) phtread_join(tid,NULL)。
p t h r e a d _ j o i n pthread\_join pthread_join函数在线程退出时,用来清理线程资源。
p h t r e a d _ j o i n phtread\_join phtread_join函数会阻塞调用方,直至 p t h r e a d _ j o i n pthread\_join pthread_join所指的线程退出。


下面是一个使用 p t h r e a d _ j o i n pthread\_join pthread_join函数的例子:

代码

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

void *my_thread_func(void *arg) {
    int i;
    int sum = 0;
    for (i = 1; i <= (int)arg; i++) {
        sum += i;
    }
    return (void *)sum;
}

int main() {
    pthread_t tid;
    int n = 5;
    if (pthread_create(&tid, NULL, my_thread_func, (void *)n) != 0) {
        printf("Error creating thread\n");
        return -1;
    }
    void *ret_val;
    if (pthread_join(tid, &ret_val) != 0) {
        printf("Error joining thread\n");
        return -1;
    }
    printf("Sum of %d numbers is %ld\n", n, (long)ret_val);
    return 0;
}

在这里插入图片描述

运行

在这里插入图片描述

解释

1.第一行:#include <pthread.h>。导入 pthread 库头文件。
2.第二行:#include <stdio.h>。导入标准输入输出库头文件。
3.第三行:#include <stdlib.h>。导入标准C 库的库文件。
4.第五行:void *my_thread_func(void *arg) {}。定义一个线程函数 my_thread_func,其参数类型为 void 指针,并返回一个指针。
5.第六行:int i;。定义一个整型变量 i,用于循环计算从1到n的和。
6.第七行:int sum = 0;。定义一个整型变量 sum,用于累加计算结果。
7.第八行:for (i = 1; i <= (int)arg; i++) {}。使用循环计算从1到n的和。
8.第九行:sum += i;。将每个数值累加到 sum 变量中。
9.第十一行:return (void *)sum;。返回计算结果,注意要将整型变量 sum 转换为 void 指针类型。
10.第十四行:定义 main 函数。
11.第十五行:pthread_t tid;。定义 pthread_t 类型的变量 tid,用于存储线程 ID。
12.第十六行:int n = 5;。定义一个整型变量 n,表示从1到n的整数之和。
13.第十七行:if (pthread_create(&tid, NULL, my_thread_func, (void *)n) != 0) {}。创建新线程并执行相应的函数,并将线程 ID 存储到 tid 中。如果创建线程失败,则打印错误信息并返回-1。
14第二十一行:void *ret_val;。定义一个 void 指针 ret_val,用于存储线程返回值
15.第二十二行:if (pthread_join(tid, &ret_val) != 0) {}。调用 pthread_join 函数等待指定线程结束,并获取其返回值。如果等待线程结束失败,则打印错误信息并返回-1。
16.第二十六行:printf(“Sum of %d numbers is %ld\n”, n, (long)ret_val);。打印从1到n的整数之和。
17.第二十七行:return 0;。返回程序正常执行结束的代码。

  • 4
    点赞
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
同步概念 所谓同步,即同时起步,协调一致。不同的对象,对“同步”的理解方式略有不同。如,设备同步,是指在两个设备之间规定一个共同的时间参考;数据库同步,是指让两个或多个数据库内容保持一致,或者按需要部分保持一致;文件同步,是指让两个或多个文件夹里的文件保持一致。等等 而,编程中、通信中所说的同步与生活中大家印象中的同步概念略有差异。“同”字应是指协同、协助、互相配合。主旨在协同步调,按预定的先后次序运行。 线程同步 同步即协同步调,按预定的先后次序运行。 线程同步,指一个线程发出某一功能调用时,在没有得到结果之前,该调用不返回。同时其它线程为保证数据一致性,不能调用该功能。 举例1: 银行存款 5000。柜台,折:取3000;提款机,卡:取 3000。剩余:2000 举例2: 内存中100字节,线程T1欲填入全1, 线程T2欲填入全0。但如果T1执行了50个字节失去cpu,T2执行,会将T1写过的内容覆盖。当T1再次获得cpu继续 从失去cpu的位置向后写入1,当执行结束,内存中的100字节,既不是全1,也不是全0。 产生的现象叫做“与时间有关的错误”(time related)。为了避免这种数据混乱,线程需要同步。 “同步”的目的,是为了避免数据混乱,解决与时间有关的错误。实际上,不仅线程间需要同步,进程间、信号间等等都需要同步机制。 因此,所有“多个控制流,共同操作一个共享资源”的情况,都需要同步。 数据混乱原因: 1. 资源共享(独享资源则不会) 2. 调度随机(意味着数据访问会出现竞争) 3. 线程间缺乏必要的同步机制。 以上3点中,前两点不能改变,欲提高效率,传递数据,资源必须共享。只要共享资源,就一定会出现竞争。只要存在竞争关系,数据就很容易出现混乱。 所以只能从第三点着手解决。使多个线程在访问共享资源的时候,出现互斥。 互斥量mutex Linux中提供一把互斥锁mutex(也称之为互斥量)。 每个线程在对资源操作前都尝试先加锁,成功加锁才能操作,操作结束解锁。 资源还是共享的,线程间也还是竞争的, 但通过“锁”就将资源的访问变成互斥操作,而后与时间有关的错误也不会再产生了。 但,应注意:同一时刻,只能有一个线程持有该锁。 当A线程对某个全局变量加锁访问,B在访问前尝试加锁,拿不到锁,B阻塞。C线程不去加锁,而直接访问该全局变量,依然能够访问,但会出现数据混乱。 所以,互斥锁实质上是操作系统提供的一把“建议锁”(又称“协同锁”),建议程序中有多线程访问共享资源的时候使用该机制。但,并没有强制限定。 因此,即使有了mutex,如果有线程不按规则来访问数据,依然会造成数据混乱。 主要应用函数: pthread_mutex_init函数 pthread_mutex_destroy函数 pthread_mutex_lock函数 pthread_mutex_trylock函数 pthread_mutex_unlock函数 以上5个函数的返回值都是:成功返回0, 失败返回错误号。 pthread_mutex_t 类型,其本质是一个结构体。为简化理解,应用时可忽略其实现细节,简单当成整数看待。 pthread_mutex_t mutex; 变量mutex只有两种取值1、0。 pthread_mutex_init函数 初始化一个互斥锁(互斥量) ---> 初值可看作1 int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr); 参1:传出参数,调用时应传 &mutex restrict关键字:只用于限制指针,告诉编译器,所有修改该指针指向内存中内容的操作,只能通过本指针完成。不能通过除本指针以外的其他变量或指针修改 参2:互斥量属性。是一个传入参数,通常传NULL,选用默认属性(线程间共享)。 参APUE.12.4同步属性 1. 静态初始化:如果互斥锁 mutex 是静态分配的(定义在全局,或加了static关键字修饰),可以直接使用宏进行初始化。e.g. pthead_mutex_t muetx = PTHREAD_MUTEX_INITIALIZER; 2. 动态初始化:局部变量应采用动态初始化。e.g. pthread_mutex_init(&mutex, NULL) pthread_mutex_destroy函数 销毁一个互斥锁 int pthread_mutex_destroy(pthread_mutex_t *mutex); pthread_mutex_lock函数 加锁。可理解为将mutex--(或-1) int pthread_mutex_lock(pthread_mutex_t *mutex); pthread_mutex_unlock函数 解锁。可理解为将mutex ++(或+1) int pthread_mutex_unlock(pthread_mutex_t *mutex); pthread_mutex_trylock函数 尝试加锁 int pthread_mutex_trylock(pthread_mutex_t *mutex); 加锁与解锁 lock与unlock: lock尝试加锁,如果加锁不成功,线程阻塞,阻塞到持有该互斥量的其他线程解锁为止。 unlock主动解锁函数,同时将阻塞在该锁上的所有线程全部唤醒,至于哪个线程先被唤醒,取决于优先级、调度。默认:先阻塞、先唤醒。 例如:T1 T2 T3 T4 使用一把mutex锁。T1加锁成功,其他线程均阻塞,直至T1解锁。T1解锁后,T2 T3 T4均被唤醒,并自动再次尝试加锁。 可假想mutex锁 init成功初值为1。 lock 功能是将mutex--。 unlock将mutex++ lock与trylock: lock加锁失败会阻塞,等待锁释放。 trylock加锁失败直接返回错误号(如:EBUSY),不阻塞。 加锁步骤测试: 看如下程序:该程序是非常典型的,由于共享、竞争而没有加任何同步机制,导致产生于时间有关的错误,造成数据混乱: #include #include #include void *tfn(void *arg) { srand(time(NULL)); while (1) { printf("hello "); sleep(rand() % 3); /*模拟长时间操作共享资源,导致cpu易主,产生与时间有关的错误*/ printf("world\n"); sleep(rand() % 3); } return NULL; } int main(void) { pthread_t tid; srand(time(NULL)); pthread_create(&tid, NULL, tfn, NULL); while (1) { printf("HELLO "); sleep(rand() % 3); printf("WORLD\n"); sleep(rand() % 3); } pthread_join(tid, NULL); return 0; } 【mutex.c】 【练习】:修改该程序,使用mutex互斥锁进行同步。 1. 定义全局互斥量,初始化init(&m, NULL)互斥量,添加对应的destry 2. 两个线程while中,两次printf前后,分别加lock和unlock 3. 将unlock挪至第二个sleep后,发现交替现象很难出现。 线程在操作完共享资源后本应该立即解锁,但修改后,线程抱着锁睡眠。睡醒解锁后又立即加锁,这两个库函数本身不会阻塞。 所以在这两行代码之间失去cpu的概率很小。因此,另外一个线程很难得到加锁的机会。 4. main 中加flag = 5 将flg在while中-- 这时,主线程输出5次后试图销毁锁,但子线程未将锁释放,无法完成。 5. main 中加pthread_cancel()将子线程取消。 【pthrd_mutex.c】 结论: 在访问共享资源前加锁,访问结束后立即解锁。锁的“粒度”应越小越好。 死锁 1. 线程试图对同一个互斥量A加锁两次。 2. 线程1拥有A锁,请求获得B锁;线程2拥有B锁,请求获得A锁 【作业】:编写程序,实现上述两种死锁现象。 读写锁 与互斥量类似,但读写锁允许更高的并行性。其特性为:写独占,读共享。 读写锁状态: 一把读写锁具备三种状态: 1. 读模式下加锁状态 (读锁) 2. 写模式下加锁状态 (写锁) 3. 不加锁状态 读写锁特性: 1. 读写锁是“写模式加锁”时, 解锁前,所有对该锁加锁的线程都会被阻塞。 2. 读写锁是“读模式加锁”时, 如果线程以读模式对其加锁会成功;如果线程以写模式加锁会阻塞。 3. 读写锁是“读模式加锁”时, 既有试图以写模式加锁的线程,也有试图以读模式加锁的线程。那么读写锁会阻塞随后的读模式锁请求。优先满足写模式锁。读锁、写锁并行阻塞,写锁优先级高 读写锁也叫共享-独占锁。当读写锁以读模式锁住时,它是以共享模式锁住的;当它以写模式锁住时,它是以独占模式锁住的。写独占、读共享。 读写锁非常适合于对数据结构读的次数远大于写的情况。 主要应用函数: pthread_rwlock_init函数 pthread_rwlock_destroy函数 pthread_rwlock_rdlock函数 pthread_rwlock_wrlock函数 pthread_rwlock_tryrdlock函数 pthread_rwlock_trywrlock函数 pthread_rwlock_unlock函数 以上7 个函数的返回值都是:成功返回0, 失败直接返回错误号。 pthread_rwlock_t类型 用于定义一个读写锁变量。 pthread_rwlock_t rwlock; pthread_rwlock_init函数 初始化一把读写锁 int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr); 参2:attr表读写锁属性,通常使用默认属性,传NULL即可。 pthread_rwlock_destroy函数 销毁一把读写锁 int pthread_rwlock_destroy(pthread_rwlock_t *rwlock); pthread_rwlock_rdlock函数 以读方式请求读写锁。(常简称为:请求读锁) int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock); pthread_rwlock_wrlock函数 以写方式请求读写锁。(常简称为:请求写锁) int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock); pthread_rwlock_unlock函数 解锁 int pthread_rwlock_unlock(pthread_rwlock_t *rwlock); pthread_rwlock_tryrdlock函数 非阻塞以读方式请求读写锁(非阻塞请求读锁) int pthread_
pthread_create函数Linux下用于创建线程的函数。它的原型如下: ```c #include <pthread.h> int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg); ``` 该函数的参数解释如下: - thread:指向pthread_t类型的指针,用于存储新创建线程的ID。 - attr:指向pthread_attr_t类型的指针,用于设置线程的属性。如果传入NULL,则使用默认属性。 - start_routine:指向一个函数的指针,该函数是新线程的起始函数。新线程将从该函数开始执行。 - arg:传递给start_routine函数的参数。 该函数的返回值为整型,表示函数执行的结果。如果成功创建线程,则返回0;如果出现错误,则返回一个错误号。 下面是一个使用pthread_create函数创建线程的示例: ```c #include <stdio.h> #include <pthread.h> void *thread_func(void *arg) { int *num = (int *)arg; printf("This is a new thread. The argument is %d\n", *num); pthread_exit(NULL); } int main() { pthread_t thread; int num = 10; int ret = pthread_create(&thread, NULL, thread_func, &num); if (ret != 0) { printf("Failed to create thread\n"); return 1; } printf("Main thread\n"); pthread_join(thread, NULL); return 0; } ``` 该示例中,我们定义了一个新线程的起始函数thread_func,该函数接收一个整型参数,并在新线程中打印该参数的值。在主线程中,我们使用pthread_create函数创建了一个新线程,并将参数传递给新线程。然后,主线程继续执行自己的代码,最后使用pthread_join函数等待新线程的结束。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

踏过山河,踏过海

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值