linux并发控制（三）

十：读写信号量

防读不防写…“

  传说中：读写信号量可允许N个读执行单元同时访问共享资源，而最多只能有一个写执行单元。

使用方法：1)定义和初始化读写信号量

              struct rw_semphore my_rws;    //定义读写信号量

              void init_rwsem(struct rw_semaphore *sem);    //初始化读写信号量

              2)读信号量获取

              void down_read(struct rw_semaphore *sem);

              int down_read_try(struct rw_semaphore *sem);

              3)读信号量释放

              void up_read(struct rw_semaphore *sem);

              4)写信号量获取

              void down_write(struct rw_semaphore *sem);

              int down_write_try(struct rw_semaphore *sem);

              5)写信号量释放

              void up_write(struct rw_semaphore *sem);

给个例子吧：

rw_semaphore rw_sem;//定义读写信号量
init_rwsem(&rw_sem);//初始化读写信号量

//读时获取信号量
down_read(&rw_sem);
...//临界资源
up_read(&rw_sem);

//写时获取信号量
down_write(&rw_sem);
...//临界资源
up_write(&rw_sem);

 

十一：互斥体(啥叫互斥体，怎么感觉前边的都是互斥体，呵呵，确实，只不过Linux开发者们觉得不过瘾，就专门研究了一个互斥体，谁让咱用人家的东西呢)

使用方法：1)定义并初始化互斥体

              struct mutex my_mutex;

              mutex_init(&my_mutex);

             2)获取互斥体

              void fastcall mutex_lock(struct mutex *lock);//引起的睡眠不能被打断

              int fastcall mutex_lock_interruptible(struct mutex *lock);//可以被打断

              int fastcall mutex_lock_trylock(struct mutex *lock);//尝试获得，获取不到也不会导致进程休眠

             3)释放互斥体

              void fastcall mutex_unlock(struct mutex *lock);

给个例子：

struct mutex my_mutex;   //定义mutex

mutex_init(&my_mutex);

 

mutex_lock(&my_mutex);

….//临界资源

mutex_unlock(&my_mutex);

 ok并发控制结束。