APUE第十一章笔记

2022-01-20 00:02:24 阅读：139 来源： 互联网

标签：返回 rwlock APUE int 第十一章笔记线程 pthread mutex

第十一章线程

11.3 线程标识

每个线程有一个线程ID。线程ID只有在它所属的进程上下文中才有意义。
实现的时候可以用-一个结构来代表pthread_t数据类型。
两个线程ID进行比较的函数

#include <pthread.h>
int pthread_equal(pthread_t tidl, pthread_t tid2);
//返回值：若相等，返回非0数值；否则，返回0

获得自身的线程ID的函数

#include <pthread.h>
pthread_t pthread_self(void) ;
//返回值：调用线程的线程D

11.4 线程创建

线程可以通过调用pthread_create函数创建。

#include <pthread.h>
int pthread_create(pthread_t *restrict tidp,
    const pthread_attr_t *restrict attr ,
    void * (*start_rn)(void *) , void *restrict arg);
//返回值：若成功、返回0；否则,返国错误编号

新创建线程的线程ID会被设置成tidp指向的内存单元。attr参数用于定制各种不同的线程属性。新创建的线程从start_rtn 函数的地址开始运行，该函数只有一个无类型指针参数arg。
新创建的线程可以访问进程的地址空间，并且继承调用线程的浮点环境和信号屏蔽字，但是该线程的挂起信号集会被清除。
每个线程都提供errno的副本。

11.5 线程终止

如果进程中的任意线程调用了exit、_Exit或者_exit，那么整个进程就会终止。
线程退出方式：

线程可以简单地从启动例程中返回，返回值是线程的退出码。
线程可以被同一进程中的其他线程取消。
线程调用pthread_exit。

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

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

#include <pthread.h>
int pthread_join(pthread_t thread, void **rval_ptr);
//返回值：若成功,返回0；否则，返回错误编号

调用线程将一直阻塞，直到指定的线程调用pthread-exit、从启动例程中返回或者被取消。
如果线程简单地从它的启动例程返回，rvalptr就包含返回码。如果线程被取消，由rvalptr指定的内存单元就设置为PTHREAD_CANCELED。
可以通过调用pthread_join自动把线程置于分离状态，这样资源就可以恢复。如果线程已经处于分离状态，pthread_join调用就会失败，返回EINVAI。
如果对线程的返回值并不感兴趣，那么可以把rvalptr设置为NULL。

线程可以通过调用pthread_cancel函数来请求取消同一进程中的其他线程。

#include <pthread.h>
int pthread_cancel(pthread_t tid);
//返回值：若成功，返回0；否则，返回错误编号

在默认情况下，pthread_cancel函数会使得由nid标识的线程的行为表现为如同调用了参数为PTHREAD_CANCELED的pthread_exit函数。但是，它仅仅提出请求。

线程可以安排它退出时需要调用的函数

#include <pthread.h>
void pthread_cleanup_push(void(*rtm)(void*), void* ang);
void pthread_cleanup_pop(int execute);

当线程执行以下动作时，清理函数工作

调用pthread_exit时
响应取消请求时
用非零execute参数调用pthread_cleanup_pop时

如果execute参数设置为0，清理函数将不被调用。
pthread_cleanup_pop都将删除上次pthread_cleanup_push调用建立的清理处理程序。

可以调用pthread_detach分离线程。

#include <pthread.h>
int pthread_detach(pthread_t tid);
//返回值：若成功，返回0；否则，返回错误编号

11.6 线程同步

当一个线程可以修改的变量，其他线程也可以读取或者修改的时候，我们就需要对这些线程进行同步.
程序使用变量的方式也会引起竞争，也会导致不一致的情况发生。

11.6.1互斥量

互斥变量是用pthread_mutex_t数据类型表示的。
在使用互斥变量以前，必须首先对它进行初始化，可以把它设置为常量PTHREADMUTEX_INITIALIZER（只适用于静态分配的互斥量），也可以通过调用pthread_mutex_init函数进行初始化。如果动态分配互斥量，在释放内存前需要调用pthread_mutex_destroy。

#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);
//两个函数的返回值：若成功，返回0；否则，返回错误编号

要用默认的属性初始化互斥量，只需把attr设为NULL。

对互斥量进行加锁，需要调用pthread_mutex_lock。如果互斥量已经上锁，调用线程将阻塞直到互斥量被解锁。
对互斥量解锁，需要调用pthread_mutex_unlock。
如果调用pthread-mutex_trylock时互斥量处于未锁住状态，那么pthread mutex_trylock将锁住互斥量，不会出现阻塞直接返回0，否则pthread-mutex_trylock就会失败，不能锁住互斥量，返回EBUSY。

#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*muter);
//所有函数的返回值：若成功，返回0；否则，返回错误编号

11.6.2 避免死锁

在同时需要两个互斥量时，总是让它们以相同的顺序加锁，这样可以避免死锁。

11.6.3 函数pthread_mutex_timedlock

pthread_mutex_timedlock互斥量原语允许绑定线程阻塞时间。在达到超时时间值时，pthread_mutex_timedlock不会对互斥量进行加锁，而是返回错误码ETIMEDOUT

#include <pthread.h>
#include <time.h>
int pthread_mutex_timedlock(pthread_mutex_t *restrict mutex, const struct timespec *restrict tsptr);
//返回值：若成功，返回0；否则，返回错误编号

11.6.4 读写锁

读写锁有3种状态：读模式下加锁状态、写模式下加锁状态、不加锁状态。一次只有一个线程可以占有写模式的读写锁，但是多个线程可以同时占有读模式的读写锁。
但是当一个线程试图以写模式获取锁时，读写锁会阻塞随后的读模式锁请求，避免读模式锁长期占用。
与互斥量相比，读写锁在使用之前必须初始化，在释放它们底层的内存之前必须销毁。

#include <pthread.h>
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
//两个函数的返回值：若成功，返回0；否则，返回错误编号

也可使用PTHREAD_RWLOCK_INITIALIZER常量对静态分配的读写锁进行初始化
要在读模式下锁定读写锁，需要调用pthread_rwlock_rdlock；要在写模式下锁定读写锁，需要调用pthread_rwlock_wrlock。不管以何种方式锁住读写锁，都调用pthread_rwlock_unlock进行解锁

#include <pthread.h>
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
//返回值：若成功，返回0；否则，返回错误编号

读写锁原语的条件版本：

#include <pthread.h>
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
//返回值：可以获取锁时，返回0；否则，返回错误EBUSY

11.6.5带有超时的读写锁

#include <pthread.h>
#include <time.h>
int pthread_rwlock_timedrdlock(pthread_rwlock_t *restrict rwlock, const struct timespec *restrict tsptr);
int pthread_rwlock_timedwrlock(pthread_rwlock_t *restrict rwlock, const struct timespec *restrict tsptr);
//返回值：若成功，返回0；若超时，返回 ETIMEOUT

11.6.6 条件变量

条件变量是线程可用的另一种同步机制，条件变量由互斥量保护，允许线程以无竞争的往事等待特定的条件发生。
条件变量上有两种基本操作：

等待：一个线程因等待条件为真而处于等待在条件变量上，此时线程不会占用互斥量（等待条件前要锁住互斥量，等待过程中对互斥量
解锁，等待到函数返回（条件改变或超时）后，互斥量再次被锁住）
通知：另一个线程在使条件为真时，通知该条件变量的等待线程（在给等待线程发信号时，不需要占有互斥量）

pthread_cond_t表示条件变量，初始化时，可以把常量PTHREAD_COND_INITIALIZER赋给静态分配的条件变量，如果条件变量是动态分配的，则需要调用pthread_cond_init函数对其进行初始化。

#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_cond_wait 等待条件变量为真

#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, const struct timespec *restrict tsptr);
//返回值：若成功，返回0；否则，返回错误编号

有两个函数可以用于通知线程条件已经满足。pthread_cond_signal函数至少能唤醒一个等待该条件的线程，而pthread_cond_broadcast函数则能唤醒等待该条件的所有线程。

#include <pthread.h>
int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond);
//返回值：若成功，返回0；否则，返回错误编号

11.6.7 自旋锁

自旋锁与互斥量类似，但它不是通过休眠使进程阻塞，而是在获取锁之前一直处于忙等阻塞状态。
pthread_spinlock_t表示自旋锁，初始化和反初始化函数为：

#include<pthread.h>
int pthread_spin_init(pthread_spinlock_t *lock, int pshared);
int pthread_spin_destroy(pthread_spinlock_t *lock);
//返回值：若成功，返回0；否则，返回错误编号

pshared参数表示进程共享属性，表明自旋锁是如何获取的。如果它设为PTHREAD_PROCESS_SHARED，则自旋锁能被可以访问锁底层内存的线程所获取，即便那些线程属于不同的进程，情况也是如此。否则pshared参数设为PTHREAD_PROCESS_PRIVATE，自旋锁就只能被初始化该锁的进程内部的线程所访问。
可以用pthread_spin_lock和pthread_spin_trylock函数对自旋锁进行加锁，前者在获取锁之前一直自旋，后者如果不能获取锁，就立即返回EBUSY错误。调用pthread_spin_unlock函数解锁：

#include <pthread.h>
int pthread_spin_lock(pthread_spinlock_t *lock);
int pthread_spin_trylock(pthread_spinlock_t *lock);
int pthread_spin_unlock(pthread_spinlock_t *lock);
//返回值：若成功，返回0；否则，返回错误编号

11.6.8 屏障

屏障允许任意数量的线程等待，直到所有的线程完成处理工作，所有线程达到屏障后可以接着工作。
初始化和反初始化

#include <pthread.h>
int pthread_barrier_init(pthread_barrier *restrict barrier, const pthread_barrierattr_t *restrict attr, unsigned int count);
int pthread_barrier_destroy(pthread_barrier *barrier);
//返回值：若成功，返回0；否则，返回错误编号

count参数指定在允许所有线程继续运行之前，必须到达屏障的线程数目。
使用pthread_barreir_wait函数来表明，线程已完成工作，准备等所有其他线程赶上来。

#include <pthread.h>
int pthread_barrier_wait(pthread_barrier_t *barrier);
//返回值：若成功，返回 0 或者 PTHREAD_BARRIER_SERIAL_THREAD；否则，返回错误编号

标签：返回,rwlock,APUE,int,第十一章,笔记,线程,pthread,mutex
来源： https://blog.csdn.net/u013162449/article/details/122584783

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9