linux系统编程——同步——互斥锁和条件变量
1. 互斥锁
互斥锁和条件变量 能用于 线程同步
如果 互斥锁 和 条件变量 存放在 共享内存中，还能 实现 进程同步
1.1 初始化互斥锁
int pthread_mutex_init(pthread_mutex_t *restrict mutex,
const pthread_mutexattr_t *restrict attr);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
// 静态分配互斥锁
static pthread_mutex_t lock = PTHREAD_MUTEX_INITALIZER;
// 动态分配
pthread_mutex_t *lock2 = malloc(sizeof(*lock2));
phread_mutex_init()
1.2 上锁
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
若资源已经被上锁，
- 调用 pthread_mutex_trylock，返回 EBUSY
- 调用 pthread_mutex_lock，被挂起。若多个线程被挂起，锁释放时，内核将唤醒 优先级最高的线程（所以必须设置不同的优先级给线程）
锁数据，不是函数
1.3 示例
生产者消费者问题
使用共享内存之类需要显示同步的情况
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#define MAXNITEMS 0x0fffffff
#define MAXNTHREADS 100
int nitems;
struct {
pthread_mutex_t mutex;
int buf[MAXNITEMS];
int nput;
int nval;
} shared = {
.mutex = PTHREAD_MUTEX_INITIALIZER
};
void *produce(void *arg);
void *consume(void *arg);
int main(int argc, char *argv[])
{
int i, nthreads, count[MAXNTHREADS];
pthread_t tid_produce[MAXNTHREADS], tid_consume;
if (argc != 3) {
printf("usage : %s <items> <threads>\n", argv[0]);
return -1;
}
nitems = atoi(argv[1]) > MAXNITEMS ? MAXNITEMS : atoi(argv[1]);
nthreads = atoi(argv[2]) > MAXNTHREADS ? MAXNTHREADS : atoi(argv[2]);
for (i = 0; i < nthreads; i++) {
count[i] = 0; // 给每个线程一个计数器，记录线程 对共享内存区域操作了多少次
pthread_create(&tid_produce[i], NULL, produce, &count[i]);
}
for (i = 0; i < nthreads; i++) {
pthread_join(tid_produce[i], NULL);
printf("count[%d] = %d\n", i, count[i]);
}
pthread_create(&tid_consume, NULL, consume, NULL);
pthread_join(tid_consume, NULL);
return 0;
}
void *produce(void *arg)
{
for (;;) {
pthread_mutex_lock(&shared.mutex);
if (shared.nput >= nitems) { // 所有的区域都写完了，退出
pthread_mutex_unlock(&shared.mutex);
return NULL;
}
shared.buf[shared.nput] = shared.nval;
shared.nput++; // nput 和 nval 增量都是 1，且初始值都是 0, 所以没有冲突情况下 shared.buf[i] == i
shared.nval++;
pthread_mutex_unlock(&shared.mutex);
*(int *)arg += 1; // 增加线程操作计数
}
}
void *consume(void *arg)
{
int i;
for (i = 0; i < nitems; ++i) {
if (shared.buf[i] != i) { // 若出现冲突，则输出
printf("buf[%d] != %d\n", i, shared.buf[i]);
}
}
return NULL;
}
加锁输出
[root@VM-0-12-centos test]# ./a.out 1000000000 5
count[0] = 54572343
count[1] = 53444696
count[2] = 47935356
count[3] = 56164561
count[4] = 56318499
不加锁
[root@localhost test]# ./a.out 10000 4
count[0] = 8596
count[1] = 8192
count[2] = 0
count[3] = 0
buf[8978] != 8977
buf[9152] != 9151
对代码进行修改，让消费者和生产者一起工作
void consume_wait(int i)
{
for (;;) {
pthread_mutex_lock(&shared.mutex);
if (i < shared.nput) {
pthread_mutex_unlock(&shared.mutex);
return;
}
pthread_mutex_unlock(&shared.mutex);
}
}
void *consume(void *arg)
{
int i;
for (i = 0; i < nitems; ++i) {
consume_wait(i); // 消费 下标为 i 的元素前，检查是否被生产
if (shared.buf[i] != i) { // 若出现冲突，则输出
printf("buf[%d] != %d\n", i, shared.buf[i]);
}
}
return NULL;
}
1.4 互斥锁的不足
生产者使用轮询的方式检查条件，浪费cpu，所以希望 能阻塞 直到 条件满足。
这需要条件变量。
2. 条件变量
互斥锁用于 上锁，条件变量用于等待
条件变量类型：pthread_cond_t
int pthread_cond_wait(pthread_cond_t *restrict cond,
pthread_mutex_t *restrict mutex);
int pthread_cond_signal(pthread_cond_t *cond);
pthread_cond_wait，用于等待条件为真，指定相关条件变量的地址，和关联互斥锁的地址
pthread_cond_signal，与信号无关，用于通知条件已为真
2.1 使用
生产者 需要生产缓存，这里是 shared变量，由于多个生产者都要操作此变量，所以shared需要关联锁。
生产消费行为 需要同步，先有生产在有消费，所以需要计数器 nready.nready，而两个线程都要操作此计数器，所以需要锁 nready.mutex，若 消费者通过阻塞在锁上实现的同步 本质 还是轮询，所以需要通知机制，所以需要 条件变量 nready.cond，让消费者能阻塞在 条件
struct {
pthread_mutex_t mutex;
int buf[MAXNITEMS]; // 存放生产者输出数据的缓存
int nput; // next 生产数据缓存 索引
int nval; // next 生产数据的值得因子
} shared = {
.mutex = PTHREAD_MUTEX_INITIALIZER
};
struct {
pthread_mutex_t mutex;
pthread_cond_t cond;
int nready;
} nready = {
.mutex = PTHREAD_MUTEX_INITIALIZER,
.cond = PTHREAD_COND_INITIALIZER
};
void *produce(void *arg)
{
for (;;) {
pthread_mutex_lock(&shared.mutex);
if (shared.nput >= nitems) { // 所有的区域都写完了，退出
pthread_mutex_unlock(&shared.mutex);
return NULL;
}
shared.buf[shared.nput] = shared.nval;
shared.nput++; // nput 和 nval 增量都是 1，且初始值都是 0, 所以没有冲突情况下 shared.buf[i] == i
shared.nval++;
pthread_mutex_unlock(&shared.mutex);
pthread_mutex_lock(&nready.mutex);
if (nready.nready == 0)
pthread_cond_signal(&nready.cond);
nready.nready++;
pthread_mutex_unlock(&nready.mutex);
*(int *)arg += 1;
}
}
void *consume(void *arg)
{
int i;
for (i = 0; i < nitems; ++i) {
pthread_mutex_lock(&nready.mutex);
while (nready.nready == 0)
pthread_cond_wait(&nready.cond, &nready.mutex);
nready.nready--;
pthread_mutex_unlock(&nready.mutex);
if (shared.buf[i] != i) { // 若出现冲突，则输出
printf("buf[%d] != %d\n", i, shared.buf[i]);
}
}
return NULL;
}
pthread_cond_wait ：
- 调用时，完成两个工作
释放锁
线程进入睡眠，直到内核收到相关条件变量的通知操作，而唤醒线程 - 返回时（被通知唤醒），完成工作
尝试获得锁，若失败，阻塞在锁上
由于 pthread_cond_wait 返回前会尝试获得锁，若此时锁被 其他线程持有，被唤醒且被调度的线程将再次进入阻塞，为避免这种情况，可修改上面代码。
int dosignal;
phtread_mutex_lock(&nready.mutex);
dosignal = (nready.nready == 0);
nready.nready++;
phtread_mutex_unlock(&nready.mutex);
if (dosignal)
pthread_cond_signal(&nready.cond);
2.2 总结
条件变量的使用大致如下：
struct {
pthread_mutex_t mutex;
pthread_cond_t cond;
维护本条件的各个变量
} var = {
.mutex = PTHREAD_MUTEX_INITIALIZER,
.cond = PTHREAD_COND_INITIALIZER
};
pthread_mutex_lock(&var.mutex);
设置条件为真
pthread_cond_signal(&var.cond);
pthread_mutex_unlock(&var.mutex);
pthread_mutex_lock(&var.mutex);
while (条件为假)
pthread_cond_wait(&var.cond, &var.mutex);
修改条件
pthread_mutex_unlock(&var.mutex);
2.4 定时等待和广播
pthread_cond_signal 只唤醒一个线程，若要唤醒多个线程，应使用 pthread_cond_broadcast。
- 为什么需要唤醒多个线程
如生产消费者模型，当生产者完成的生产足够满足多个消费者，则应该唤醒多个线程 - 推荐始终使用广播
使用单播能优化程序，但由于必须明确每个等待线程，且唤醒哪个等待线程无关紧要。所以使用广播更安全，简单。
int pthread_cond_broadcast(pthread_cond_t *cond);
int pthread_cond_timedwait(pthread_cond_t *restrict cond,
pthread_mutex_t *restrict mutex,
const struct timespec *restrict abstime);
struct timespec {
time_t tv_sec; // sec
time_t tv_nsec; // nanosec
pthread_cond_timedwait 可以设置超时时间，若超时则返回 ETIME。
超时是绝对时间，不是相对时间。
3. 互斥量和条件变量属性
3.1 静态初始化
用于线程间同步，我们使用 常量值 PTHREAD_MUTEX_INITIALIZER 和 PTHREAD_COND_INITIALIZER 初始化 互斥量 和 条件变量。
这种方式让其 使用默认属性。
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
3.2 动态初始化
使用如下函数，初始化和销毁
int pthread_mutex_destroy(pthread_mutex_t *mutex);
int pthread_mutex_init(pthread_mutex_t *restrict mutex,
const pthread_mutexattr_t *restrict attr);
int pthread_cond_destroy(pthread_cond_t *cond);
int pthread_cond_init(pthread_cond_t *restrict cond,
const pthread_condattr_t *restrict attr);
attr参数若为NULL，则使用默认值初始化。
通过如下函数 初始化和销毁 attr
int pthread_mutexattr_init(pthread_mutexattr_t *attr);
int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);
int pthread_condattr_destroy(pthread_condattr_t *attr);
int pthread_condattr_init(pthread_condattr_t *attr);
3.3 启用属性
一旦 互斥锁属性对象 条件变量属性对象 已初始化，就调用 不同函数启用或禁止特定属性。
如开启进程间共享的函数
int pthread_mutexattr_getpshared(const pthread_mutexattr_t *attr, int *valptr);
int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int value);
int pthread_condattr_getpshared(const pthread_mutexattr_t *attr, int *valptr);
int pthread_condattr_setpshared(pthread_mutexattr_t *attr, int value);
value 的值可以是：
PTHREAD_PROCESS_PRIVATE 或 PTHREAD_PROCESS_SHARED
示例
pthread_mutex_t *mptr;
pthread_mutexattr_t mattr;
mptr = /* 进程间共享内存区 分配的 pthread_mutex_t 对象 */
pthread_mutexattr_init(&mattr);
pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED);
pthread_mutex_init(mptr, &mattr);
4. 持有锁期间进程终止
一个进程或线程持有锁，若持有锁期间被终止，锁是否被系统自动释放？
4.1 进程间共享
- 互斥锁 ： 不会
- 读写锁 ： 不会
- fnctl记录锁 ： 进程终止时，内核自动清理锁
- systemV信号量 ：应用程序可以选择进程终止时，内核是否自动清理某个信号量（SEM_UNDO）
- POSIX信号量 ： 不会
4.2 线程间共享
当一个线程持有锁时，其可能退出，如 另一个线程取消他，或他自己调用 pthread_exit。
- 自愿（pthread_exit）：线程应该知道自己持有锁，应该自己释放
- 非自愿（另一个线程取消）：线程可以安装退出清理函数释放持有锁
若由于段错误等原因导致整个进程退出，就回到进程间共享情况
4.3 内核释放锁的意义
若进程退出，锁由内核释放，通常是没意义的，因为同步区数据是脏的。
但以下情况，内核释放锁是有意义的：
- 服务器可能使用一个 systemv信号量（打开SEM_UNDO）来统计当前处理客户数，如 fork一个子进程，信号量加一，子进程终止时，内核将信号量减一
- 守护进程希望系统只运行一个实例，守护进程在开始时在自己某个数据文件获得写入锁，然后运行期间持有锁，若有人试图启动守护进程的另外副本，则新副本由于无法持有锁而退出，若守护进程终止时，内核释放写入锁，从而允许启动该守护进程的副本。
