7.10-第十课:线程同步

Posted xuxaut-558

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了7.10-第十课:线程同步相关的知识,希望对你有一定的参考价值。

================
第十课  线程同步
================

一、竞争与同步
--------------

当多个线程同时访问其所共享的进程资源时,
需要相互协调,以防止出现数据不一致、
不完整的问题。这就叫线程同步。

范例:vie.c

理想中的原子++:

-----------------+-----------------+------
       线程1     |       线程2     | 内存
--------+--------+--------+--------+------
 指  令 | 寄存器 | 指  令 | 寄存器 | g_cn
--------+--------+--------+--------+------
 读内存 |    0   |        |        |   0
 算加法 |    1   |        |        |   0
 写内存 |    1   |        |        |   1
        |        | 读内存 |    1   |   1
        |        | 算加法 |    2   |   1
        |        | 写内存 |    2   |   2
--------+--------+--------+--------+------

现实中的非原子++:

-----------------+-----------------+------
       线程1     |       线程2     | 内存
--------+--------+--------+--------+------
 指  令 | 寄存器 | 指  令 | 寄存器 | g_cn
--------+--------+--------+--------+------
 读内存 |    0   |        |        |   0
        |        | 读内存 |    0   |   0
 算加法 |    1   |        |        |   0
        |        | 算加法 |    1   |   0
 写内存 |    1   |        |        |   1
        |        | 写内存 |    1   |   1
--------+--------+--------+--------+------

二、互斥量
----------

int pthread_mutex_init (pthread_mutex_t* mutex,
    const pthread_mutexattr_t* mutexattr);

亦可

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

int pthread_mutex_lock (pthread_mutex_t* mutex);

int pthread_mutex_unlock (pthread_mutex_t* mutex);

int pthread_mutex_destroy (pthread_mutex_t* mutex);

1) 互斥量被初始化为非锁定状态;

2) 线程1调用pthread_mutex_lock函数,立即返回,
   互斥量呈锁定状态;

3) 线程2调用pthread_mutex_lock函数,阻塞等待;

4) 线程1调用pthread_mutex_unlock函数,
   互斥量呈非锁定状态;

5) 线程2被唤醒,从pthread_mutex_lock函数中返回,
互斥量呈锁定状态;

...

范例:mutex.c

三、信号量
----------

信号量是一个计数器,用于控制访问有限共享资源的线程数。

#include <semaphore.h>

// 创建信号量
int sem_init (sem_t* sem, int pshared,
    unsigned int value);

sem     - 信号量ID,输出。

pshared - 一般取0,表示调用进程的信号量。
          非0表示该信号量可以共享内存的方式,
          为多个进程所共享(Linux暂不支持)。

value   - 信号量初值。

// 信号量减1,不够减即阻塞
int sem_wait (sem_t* sem);

// 信号量减1,不够减即返回-1,errno为EAGAIN
int sem_trywait (sem_t* sem);

// 信号量减1,不够减即阻塞,
// 直到abs_timeout超时返回-1,errno为ETIMEDOUT
int sem_timedwait (sem_t* sem,
    const struct timespec* abs_timeout);

struct timespec {
    time_t tv_sec;  // Seconds
    long   tv_nsec; // Nanoseconds [0 - 999999999]
};

// 信号量加1
int sem_post (sem_t* sem);

// 销毁信号量
int sem_destroy (sem_t* sem);

范例:sem.c

注意:

1) 信号量APIs没有声明在pthread.h中,
   而是声明在semaphore.h中,失败也不返回错误码,
   而是返回-1,同时设置errno。

2) 互斥量任何时候都只允许一个线程访问共享资源,
   而信号量则允许最多value个线程同时访问共享资源,
   当value为1时,与互斥量等价。

范例:pool.c

四、死锁问题
------------

线程1   线程2
  |       |
获取A   获取B
  |       |
获取B   获取A <- 死锁
      /
释放B X 释放A
     /
释放A   释放B

范例:dead.c

五、条件变量
------------

生产者消费者模型

生产者:产生数据的线程。
消费者:使用数据的线程。

通过缓冲区隔离生产者和消费者,与二者直连相比,
避免相互等待,提高运行效率。

生产快于消费,缓冲区满,撑死。
消费快于生产,缓冲区空,饿死。

条件变量可以让调用线程在满足特定条件的情况下暂停。

int pthread_cond_init (pthread_cond_t* cond,
    const pthread_condattr_t* attr);

亦可

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

// 使调用线程睡入条件变量cond,同时释放互斥锁mutex
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);

struct timespec {
    time_t tv_sec;  // Seconds
    long   tv_nsec; // Nanoseconds [0 - 999999999]
};

// 从条件变量cond中唤出一个线程,
// 令其重新获得原先的互斥锁
int pthread_cond_signal (pthread_cond_t* cond);

注意:被唤出的线程此刻将从pthread_cond_wait函数中返回,
但如果该线程无法获得原先的锁,则会继续阻塞在加锁上。

// 从条件变量cond中唤出所有线程
int pthread_cond_broadcast (pthread_cond_t* cond);

int pthread_cond_destroy (pthread_cond_t* cond);

范例:cond.c

注意:当一个线程被从条件变量中唤出以后,
导致其睡入条件变量的条件可能还需要再判断一次,
因其随时有可能别其它线程修改。

范例:bc.c (if->while)

六、哲学家就餐问题
------------------

1965年,著名计算机科学家艾兹格·迪科斯彻,提出并解决
了一个他称之为哲学家就餐的同步问题。从那时起,每个发
明同步原语的人,都希望通过解决哲学家就餐问题来展示其
同步原语的精妙之处。

这个问题可以简单地描述如下:

五个哲学家围坐在一张圆桌周围,每个哲学家面前都有一盘
通心粉。由于通心粉很滑,所以需要两把叉子才能夹住。相
邻两个盘子之间放有一把叉子。哲学家的生活中有两种交替
活动时段:即吃饭和思考。当一个哲学家觉得饿了时,他就
试图分两次去取其左边和右边的叉子,每次拿一把,但不分
次序。如果成功地得到了两把叉子,就开始吃饭,吃完后放
下叉子继续思考。

图示:dining.png

关键问题是:能为每一个哲学家写一段描述其行为的程序,
且决不会死锁吗?

提示:

如果五位哲学家同时拿起左面的叉子,就没有人能够拿到他
们各自右面的叉子,于是发生了死锁。

如果每位哲学家在拿到左面的叉子后,发现其右面的叉子不
可用,那么就先放下左面的叉的,等待一段时间,再重复此
过程。可能在某一个瞬间,所有的哲学家都同时拿起左叉,
看到右叉不可用,又都放下左叉,等一会儿,又都同时拿起
左叉,如此重复下去。虽然程序在不停运行,但都无法取得
进展,于是发生了活锁。

思路:

解决问题的关键在于,必须保证任意一位哲学家只有在其左
右两个邻居都没有在进餐时,才允许其进入进餐状态。这样
做不仅不会发生死锁,而且对于任意数量的哲学家都能获得
最大限度的并行性。

范例:dining.c

















































































以上是关于7.10-第十课:线程同步的主要内容,如果未能解决你的问题,请参考以下文章

第十次总结 线程的异步和同步

Linux篇第十四篇——多线程(线程同步和互斥+线程安全+条件变量)

Linux篇第十四篇——多线程(线程同步和互斥+线程安全+条件变量)

第十九节——线程与同步代码块和锁

JAVA-初步认识-第十三章-同步的前提

201871010101-陈来弟《面向对象程序设计(java)》第十七周学习总结