spinlock 和 Semaphore信号量的区别_百度知道
spinlock 和 Semaphore信号量的区别
我有更好的答案
Mutex是一把钥匙，一个人拿了就可进入一个房间，出来的时候把钥匙交给队列的第一个。一般的用法是用于串行化对critical section代码的访问，保证这段代码不会被并行的运行。Semaphore是一件可以容纳N人的房间，如果人不满就可以进去，如果人满了，就要等待有人出来。对于N=1的情况，称为binary semaphore。一般的用法是，用于限制对于某一资源的同时访问。Binary semaphore与Mutex的差异：在有的系统中Binary semaphore与Mutex是没有差异的。在有的系统上，主要的差异是mutex一定要由获得锁的进程来释放。而semaphore可以由其它进程释放（这时的semaphore实际就是个原子的变量，大家可以加或减），因此semaphore可以用于进程间同步。Semaphore的同步功能是所有系统都支持的，而Mutex能否由其他进程释放则未定，因此建议mutex只用于保护critical section。而semaphore则用于保护某变量，或者同步。另一个概念是spin lock，这是一个内核态概念。spin lock与semaphore的主要区别是spin lock是busy waiting，而semaphore是sleep。对于可以sleep的进程来说，busy waiting当然没有意义。对于单CPU的系统，busy waiting当然更没意义（没有CPU可以释放锁）。因此，只有多CPU的内核态非进程空间，才会用到spin lock。Linux kernel的spin lock在非SMP的情况下，只是关irq，没有别的操作，用于确保该段程序的运行不会被打断。其实也就是类似mutex的作用，串行化对critical section的访问。但是mutex不能保护中断的打断，也不能在中断处理程序中被调用。而spin lock也一般没有必要用于可以sleep的进程空间。--------------------------------------------------------------------------------------------- 内核同步措施
为了避免并发，防止竞争。内核提供了一组同步方法来提供对共享数据的保护。 我们的重点不是介绍这些方法的详细用法，而是强调为什么使用这些方法和它们之间的差别。
Linux 使用的同步机制可以说从2.0到2.6以来不断发展完善。从最初的原子操作，到后来的信号量，从大内核锁到今天的自旋锁。这些同步机制的发展伴随 Linux从单处理器到对称多处理器的过度；伴随着从非抢占内核到抢占内核的过度。锁机制越来越有效，也越来越复杂。
目前来说内核中原子操作多用来做计数使用，其它情况最常用的是两种锁以及它们的变种:一个是自旋锁，另一个是信号量。我们下面就来着重介绍一下这两种锁机制。自旋锁
自旋锁是专为防止多处理器并发而引入的一种锁，它在内核中大量应用于中断处理等部分(对于单处理器来说，防止中断处理中的并发可简单采用关闭中断的方式，不需要自旋锁)。
自旋锁最多只能被一个内核任务持有，如果一个内核任务试图请求一个已被争用(已经被持有)的自旋锁，那么这个任务就会一直进行忙循环——旋转——等待锁重新可用。要是锁未被争用，请求它的内核任务便能立刻得到它并且继续进行。自旋锁可以在任何时刻防止多于一个的内核任务同时进入临界区，因此这种锁可有效地避免多处理器上并发运行的内核任务竞争共享资源。
事实上，自旋锁的初衷就是：在短期间内进行轻量级的锁定。一个被争用的自旋锁使得请求它的线程在等待锁重新可用的期间进行自旋(特别浪费处理器时间)，所以自旋锁不应该被持有时间过长。如果需要长时间锁定的话, 最好使用信号量。自旋锁的基本形式如下：
spin_lock(&mr_lock);
spin_unlock(&mr_lock);
因为自旋锁在同一时刻只能被最多一个内核任务持有，所以一个时刻只有一个线程允许存在于临界区中。这点很好地满足了对称多处理机器需要的锁定服务。在单处理器上，自旋锁仅仅当作一个设置内核抢占的开关。如果内核抢占也不存在，那么自旋锁会在编译时被完全剔除出内核。
简单的说，自旋锁在内核中主要用来防止多处理器中并发访问临界区，防止内核抢占造成的竞争。另外自旋锁不允许任务睡眠(持有自旋锁的任务睡眠会造成自死锁——因为睡眠有可能造成持有锁的内核任务被重新调度，而再次申请自己已持有的锁)，它能够在中断上下文中使用。
死锁：假设有一个或多个内核任务和一个或多个资源，每个内核都在等待其中的一个资源，但所有的资源都已经被占用了。这便会发生所有内核任务都在相互等待，但它们永远不会释放已经占有的资源，于是任何内核任务都无法获得所需要的资源，无法继续运行，这便意味着死锁发生了。自死琐是说自己占有了某个资源，然后自己又申请自己已占有的资源，显然不可能再获得该资源，因此就自缚手脚了。信号量
Linux中的信号量是一种睡眠锁。如果有一个任务试图获得一个已被持有的信号量时，信号量会将其推入等待队列，然后让其睡眠。这时处理器获得自由去执行其它代码。当持有信号量的进程将信号量释放后，在等待队列中的一个任务将被唤醒，从而便可以获得这个信号量。
信号量的睡眠特性，使得信号量适用于锁会被长时间持有的情况；只能在进程上下文中使用，因为中断上下文中是不能被调度的；另外当代码持有信号量时，不可以再持有自旋锁。信号量基本使用形式为：static DECLARE_MUTEX(mr_sem);//声明互斥信号量if(down_interruptible(&mr_sem))
//可被中断的睡眠，当信号来到，睡眠的任务被唤醒
//临界区up(&mr_sem);信号量和自旋锁区别
虽然听起来两者之间的使用条件复杂，其实在实际使用中信号量和自旋锁并不易混淆。注意以下原则:
如果代码需要睡眠——这往往是发生在和用户空间同步时——使用信号量是唯一的选择。由于不受睡眠的限制，使用信号量通常来说更加简单一些。如果需要在自旋锁和信号量中作选择，应该取决于锁被持有的时间长短。理想情况是所有的锁都应该尽可能短的被持有，但是如果锁的持有时间较长的话，使用信号量是更好的选择。另外，信号量不同于自旋锁，它不会关闭内核抢占，所以持有信号量的代码可以被抢占。这意味者信号量不会对影响调度反应时间带来负面影响。自旋锁对信号量需求
建议的加锁方法低开销加锁
优先使用自旋锁短期锁定
优先使用自旋锁长期加锁
优先使用信号量中断上下文中加锁
使用自旋锁持有锁是需要睡眠、调度
使用信号量
采纳率：86%
为您推荐：
其他类似问题
semaphore的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。最近的多线程 想实现这样的功能： 多线程Socket获得的数据 对其进行某种处理FuncA，但是FuncA比较耗时，希望能够单独独立出来，这样 接受和处理数据分开，但是FuncA处理数据不能放入一个线程，否则很慢，要多线程处理，这个时候 就要使用 多线程 信号量 semaphore了。【我是在windows下 使用pthread win32 的】
在pthread win32源码中，semaphore.h是这样定义的：
typedef struct sem_t_ * sem_t;
下面是这个结构的定义
* ====================
* ====================
* Semaphores, Mutexes and Condition Variables
* ====================
* ====================
struct sem_t_
pthread_mutex_t lock;
#if defined(NEED_SEM)
int leftToU
其方法有：
int sem_init (sem_t * sem,int pshared,unsigned int value);
int sem_destroy (sem_t * sem);
int sem_trywait (sem_t * sem);
int sem_wait (sem_t * sem);
int sem_timedwait (sem_t * sem,const struct timespec * abstime);
int sem_post (sem_t * sem);
int sem_post_multiple (sem_t * sem,int count);
int sem_getvalue (sem_t * sem,int * sval);
//没有实现的有
int sem_open (const char * name,int oflag,mode_t mode,unsigned int value);
int sem_close (sem_t * sem);
int sem_unlink (const char * name);
没有实现的 函数代码都是类似下面这样的，直接是返回错误：
sem_open (const char *name, int oflag, mode_t mode, unsigned int value)
printf("本函数没有实现\n");//本人添加的 以免误用
errno = ENOSYS;
return -1;
/* sem_open */
好，下面说重点了，sem_t 就是 semaphore信号量 怎么用。
1、定义sem_t结构体
sem_t 就是一个结构体指针，定义了，是没有值的。比如
sem_t sem=NULL;
2、初始化sem_t变量
sem_init(&sem,0,0);
显然内部会分配内存，返回值为0，如果失败为非0【其实是-1，只有两种返回值，纳闷为什么不用boolean】，错误存储在errno中。
第二个参数 为0，为1 是可以在多进程中使用，但是pthread win32没有实现，所以保证永远为0；
第三个参数是初始值，如果大于0，则会发送多少个sem_post操作的。一般设置0 即可。
3、在多线程中 等待
sem_wait(&sem);
sem_timedwait(&sem,&const struct timespec *abstime));
sem_trywait(&sem);
&sem_wait是阻塞的，sem_timewait是阻塞一定时间后继续，sem_trywait是非阻塞的，非阻塞怎么用，我暂时没研究。
总之呢，wait之后，内部value就会-1；所以如果vaue小于0，那么就有线程正在等待，否则就不等待直接进行下面的工作了。
4、【重点】在主线程或其他地方 发送post，让那些工作线程逐个开始工作起来
sem_post(&sem);//让value+1
sem_post_multi(&sem,5);&//让vaue+5
5、当然就是结束了,当且仅当 sem有效 且 内部value&=0的时候，也就是没有sem_wait的时候可以销毁。
sem_destroy(&sem);
此时 sem_wait 就会失败了。所以destroy前 先 sem_post& value的绝对值 个信号 就可以了。
6、【补充】获得sem内部的value值，当且仅当==0的时候，才可以destroy，小于0 队列个数，大于0 排队数量。
sem_getvalue(&sem,&theOutValue);
以上返回值为0 正常，否则不正常。
使用这个semaphore有一个好处，比如，只有2个线程，你一下子sem_post 20次，没关系，sem_wait会执行20次的，而且是2个线程轮流。其及时对WINAPI semaphore的一个封装。
&semaphore如果在一个线程中使用，一般叫做 binary semaphore，单值。
&ps：signal.h 头文件 叫做信号 ，与这个semaphore信号量 不太一样的。
附上 临界区，互斥量，信号量，事件的区别 ，这些都属于& 线程安全的范畴，不知道还有别的没有了。
临界区，互斥量，信号量，事件的区别
===================================
四种进程或线程同步互斥的控制方法
1、临界区:通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。
2、互斥量:为协调共同对一个共享资源的单独访问而设计的。
3、信号量:为控制一个具有有限数量用户资源而设计。
4、事 件:用来通知线程有一些事件已发生，从而启动后继任务的开始。
临界区(Critical Section)(同一个进程内，实现互斥)
===================================
保证在某一时刻只有一个线程能访问数据的简便办法。在任意时刻只允许一个线程对共享资源进行访问。如果有多个线程试图同时访问临界区，那么在有一个线程进入后其他所有试图访问此临界区的线程将被挂起，并一直持续到进入临界区的线程离开。临界区在被释放后，其他线程可以继续抢占，并以此达到用原子方式操作共享资源的目的。
互斥量(Mutex)(可以跨进程，实现互斥)
===================================
互斥量跟临界区很相似，只有拥有互斥对象的线程才具有访问资源的权限，由于互斥对象只有一个，因此就决定了任何情况下此共享资源都不会同时被多个线程所访问。当前占据资源的线程在任务处理完后应将拥有的互斥对象交出，以便其他线程在获得后得以访问资源。互斥量比临界区复杂。因为使用互斥不仅仅能够在同一应用程序不同线程中实现资源的安全共享，而且可以在不同应用程序的线程之间实现对资源的安全共享。
互斥量与临界区的作用非常相似，但互斥量是可以命名的，也就是说它可以跨越进程使用。所以创建互斥量需要的资源更多，所以如果只为了在进程内部是用的话使用临界区会带来速度上的优势并能够减少资源占用量。
信号量(Semaphores)(主要是实现同步，可以跨进程)
===================================
信号量对象对线程的同步方式与前面几种方法不同，信号允许多个线程同时使用共享资源，这与操作系统中的PV操作相同。它指出了同时访问共享资源的线程最大数目。它允许多个线程在同一时刻访问同一资源，但是需要限制在同一时刻访问此资源的最大线程数目。一般是将当前可用资源计数设置为最大资源计数，每增加一个线程对共享资源的访问，当前可用资源计数就会减1，只要当前可用资源计数是大于0的，就可以发出信号量信号。但是当前可用计数减小到0时则说明当前占用资源的线程数已经达到了所允许的最大数目，不能在允许其他线程的进入，此时的信号量信号将无法发出
事件(Event)(实现同步，可以跨进程)
===================================
事件对象也可以通过通知操作的方式来保持线程的同步。并且可以实现不同进程中的线程同步操作。
最后附上我自己的测试源代码：
#include &stdio.h&
#include &pthread.h&
#include &sched.h&
#include &semaphore.h&
#include &conio.h&//for getch()
#include &ctype.h&
#include&Windows.h&
#pragma comment(lib, "pthreadVC2.lib")
//必须加上这句
void*SemThreadWorker(void* Param)
printf("#1 [child %s]I am Waiting\n",Param);
//sem_wait(&sem);
//sem_timedwait(&sem,60);
//sem_trywait(&sem);
while(0==sem_wait(&sem)) {
// Wait semaphore
[child %s]I am Working in 1 second!!\n",Param);
Sleep(1000);
printf("#2 [child %s]I am Exit\n",Param);
return (void *)10;
int main()
int ret=0;
ret=sem_init(&sem,0/*int pshared process_shared*/,0/*uint init_value*/);/*SEM_VALUE_MAX == int_max*/
if(ret!=0){
printf("Semaphore
initialize failed");
exit(EXIT_FAILURE);
if(0==sem_getvalue(&sem,&ret)){printf("\n sem_getvalue value=%d \n",ret);}else{perror("@Error sem_getValue");}
//CreateThreads
pthread_t tids[5];
ret = pthread_create(&tids[0], NULL, SemThreadWorker, "1");
if (ret) {printf("Thread creation failed!!\n");exit(EXIT_FAILURE);}
ret = pthread_create(&tids[1], NULL, SemThreadWorker, "2");
if (ret) {printf("Thread creation failed!!\n");exit(EXIT_FAILURE);}
ret = pthread_create(&tids[2], NULL, SemThreadWorker, "3");
if (ret) {printf("Thread creation failed!!\n");exit(EXIT_FAILURE);}
ret = pthread_create(&tids[3], NULL, SemThreadWorker, "4");
if (ret) {printf("Thread creation failed!!\n");exit(EXIT_FAILURE);}
ret = pthread_create(&tids[4], NULL, SemThreadWorker, "5");
if (ret) {printf("Thread creation failed!!\n");exit(EXIT_FAILURE);}
Sleep(100);
printf("\n Post semaphore发送信号量过去: sem_post(&sem);\n");
//for(int i=0;i&10;i++){
sem_post(&sem);
sem_post(&sem);
Sleep(100);
if(sem_post(&sem)!=0){
printf("Error sem_post ");
if(0==sem_getvalue(&sem,&ret)){printf("\n sem_getvalue value=%d \n",ret);}else{perror("@Error sem_getValue");}
if(sem_post(&sem)!=0){
printf("Error sem_post ");
if(0==sem_getvalue(&sem,&ret)){printf("\n sem_getvalue value=%d \n",ret);}else{perror("@Error sem_getValue");}
if(sem_post_multiple(&sem,5)!=0){
printf("Error sem_post_multiple ");
if(0==sem_getvalue(&sem,&ret)){printf("\n sem_getvalue value=%d \n",ret);}else{perror("@Error sem_getValue");}
Sleep(2000);
printf("\n sem_getvalue(&sem,&ret);\n");
//sem_open
//sem_close(&sem);
//sem_unlink
if(0==sem_getvalue(&sem,&ret)){printf("\n sem_getvalue value=%d \n",ret);}else{perror("@Error sem_getValue");}
//为了让sem_wait全部停止阻塞，才可以destroy
sem_post_multiple(&sem,-ret);
printf("\n sem_destroy(&sem);\n\n");
//第一次 sem_destroy return 0
if(sem_destroy(&sem)!=0){
perror("@Error sem_destroy ");
//第二次 sem_destroy 多次 return -1
if(sem_destroy(&sem)!=0){
perror("@Error sem_destroy ");
if(sem_post(&sem)!=0){
printf("@Error sem_post \n");
printf(" Wait for thread pthread_join synchronization...\n");
void *threadResult=NULL;
ret = pthread_join(tids[0], &threadResult);
if (ret){printf("Thread join failed!!\n");exit(EXIT_FAILURE);}
ret = pthread_join(tids[1], &threadResult);
if (ret){printf("Thread join failed!!\n");exit(EXIT_FAILURE);}
ret = pthread_join(tids[2], &threadResult);
if (ret){printf("Thread join failed!!\n");exit(EXIT_FAILURE);}
ret = pthread_join(tids[3], &threadResult);
if (ret){printf("Thread join failed!!\n");exit(EXIT_FAILURE);}
ret = pthread_join(tids[4], &threadResult);
if (ret){printf("Thread join failed!!\n");exit(EXIT_FAILURE);}
printf("press any key to continue...\n");
//getchar();
五个线程工作，用semaphore来管理队列
阅读(...) 评论()spinlock_t自旋锁和semaphore信号量
自旋锁是一直循环检查， 直到锁上为止(锁不上也不会让进程休眠)。自旋锁只有两种状态，可锁上和锁不上. 锁上后确保执行的代码为原子操作, 直到解锁为止. 注意不能长时间锁上自旋锁， 不能在临界区里休眠.
spinlock_t 自旋锁
＃include &linux/spinlock.h&
spin_lock_init(&mylock);
//初始化自旋锁, 初始化过后是可锁上状态.
spin_lock(&mylock);
//spin_lock_irq 不让中断打断执行
保护执行的代码
//临界区, 在临界区里不能执行会休眠的代码
spin_unlock(&mylock); //spin_unlock_irq
当自旋锁锁上后， 拥有此锁的进程不能进入休眠. 自旋锁只适用于保护执行时间较短的代码.
如用于前面的计数例子.
#include &linux/init.h&
#include &linux/module.h&
#include &linux/fs.h&
#include &linux/miscdevice.h&
#include &linux/sched.h&
#include &asm/current.h&
#include &linux/spinlock.h&
int count = 0;
ssize_t myread(struct file *fl, char __user *buf, size_t len, loff_t *off)
printk("pid = %d, %s, count = %d\n", current-&pid, current-&comm, count);
ssize_t mywrite(struct file *fl, const char __user *buf, size_t len, loff_t *off)
spin_lock(&mylock);
spin_unlock(&mylock);
struct file_operations fops = {
.owner = THIS_MODULE,
.read = myread,
.write = mywrite,
struct miscdevice mymdev = {
.minor = MISC_DYNAMIC_MINOR,
.name = "mymdev",
.fops = &fops,
static int __init test_init(void)
spin_lock_init(&mylock);
return misc_register(&mymdev);
static void __exit test_exit(void)
misc_deregister(&mymdev);
module_init(test_init);
module_exit(test_exit);
MODULE_LICENSE("GPL");
//////////////////////////////////////////////////////////////
信号量, 当锁不上时， 当前进程会进入睡眠状态， 直到被up唤醒为止.
信号量可用于生产/消费的模型. 信号量的状态可有多种，一个锁可被锁上多次, 只要有资源都可以上锁.
#include &linux/semaphore.h&
struct semaphore {
unsigned int
struct list_head wait_
void sema_init(struct semaphore *sem, int val);
void down(struct semaphore *sem);
int down_interruptible(struct semaphore *sem);
int down_trylock(struct semaphore *sem);
int down_timeout(struct semaphore *sem, long jiffies);
void up(struct semaphore *sem);
////////////
如用信号量实现生产/消费的模型. 一个进程读取驱动里的数据(消费), 另一个进程写入数据到驱动(生产).在驱动源码里把写入的数据用内核存放起来，当读进程获取数据后，还需从内核链表里移除数据.
#include &linux/init.h&
#include &linux/module.h&
#include &linux/fs.h&
#include &linux/miscdevice.h&
#include &linux/sched.h&
#include &asm/current.h&
#include &linux/spinlock.h&
#include &linux/semaphore.h&
#include &linux/slab.h&
#include &asm/uaccess.h&
static LIST_HEAD(dlist);
typedef struct {
char data[1000];
struct list_head list;
ssize_t myread(struct file *fl, char __user *buf, size_t len, loff_t *off)
struct list_head *
ret = down_interruptible(&sem);
if (ret & 0)
return -ERESTART;
tmp = dlist.
if (tmp == &dlist)
return -ENODATA;
data = container_of(tmp, data_t, list);
ret = copy_to_user(buf, data-&data, data-&len);
ret = data-&len -
spin_lock(&mylock);
list_del(tmp);
spin_unlock(&mylock);
kfree(data);
printk("after down: pid = %d, %s\n", current-&pid, current-&comm);
ssize_t mywrite(struct file *fl, const char __user *buf, size_t len, loff_t *off)
data_t *data = kzalloc(sizeof(data_t), GFP_KERNEL);
ret = copy_from_user(data-&data, buf, len);
data-&len = len-
spin_lock(&mylock);
list_add_tail(&data-&list, &dlist);
spin_unlock(&mylock);
struct file_operations fops = {
.owner = THIS_MODULE,
.read = myread,
.write = mywrite,
struct miscdevice mymdev = {
.minor = MISC_DYNAMIC_MINOR,
.name = "mymdev",
.fops = &fops,
static int __init test_init(void)
sema_init(&sem, 0);
spin_lock_init(&mylock);
return misc_register(&mymdev);
static void __exit test_exit(void)
misc_deregister(&mymdev);
module_init(test_init);
module_exit(test_exit);
MODULE_LICENSE("GPL");
没有更多推荐了，E-Mail: walter.
spinlock和semaphore的差别和应用
这两天经常有同事在问我spinlock和semaphore的相关问题，什么时候该用spinlock？什么时候该用semaphore？什么时候该用spinlock_irq？什么时候该用spinlock_irqsave？的确，对于初涉内核开发的人员来说，spinlock和semaphore的应用是一个比较大的疑问。这里，我来谈谈我对这两个概念的想法吧。
Spinlock的实现机制可以描述如下：CPU首先将内存总线lock住，然后检测内存中的lock数据，如果数据为真，那么表示资源被人占用，无法获取。然后CPU会自璇检测该lock数据，直到数据不为真之后，lock该数据返回。在Linux中spinlock核心代码采用汇编语言实现，可以参考__raw_spin_lock函数。在2.6.25版本之后，Linux为了解决在多CPU平台上的不公平竞争，引入了排队自璇锁的算法。
说道这里，需要讲一下的是，spinlock在up平台上为空函数的说法。这个说法不是很严格，实际上在非强占的up平台上，spinlock的实现为空函数，在可强占的up平台上，spinlock需要将强占给disable掉，也就是说在spinlock的临界区，Linux无法强占。在多CPU平台上，spinlock是有效的。
Semaphore的实现机制可以描述如下：CPU首先会检测信号量是否可获取，如果无法获取该信号量，那么就会导致一次上下文调度操作。从实现机制上来看，semaphore操作效率比较低，而spinlock的效率相对较高，但是这种效率的高低与应用相关，如果临界区操作的时间过长，那么采用spinlock会浪费大量的CPU时间，还不如做几次上下文调度释放CPU资源呢。所以，spinlock的应用有一个原则，那就是临界区操作尽可能的短，让CPU不要自璇太多的时间，这一点从spinlock的实现代码上也可以看出一些端倪，Linux开发人员着这个地方花费了好多心计。
从上面的机制描述，我想可以总结出如下几点：
1、不允许睡眠的上下文需要采用spinlock，可以睡眠的上下文可以采用semaphore。在中断上下文中访问的竞争资源一定采用spinlock。
2、临界区操作较长的应用建议采用semaphore，临界区很短的操作建议采用spinlock。
3、需要关中断的场合需要调用spinlock_irq或者spinlock_irqsave，不明确当前中断状态的地方需要调用spinlock_irqsave，否则调用spinlock_irq。一个资源既在中断上下文中访问，又在用户上下文中访问，那么需要关中断，如果仅仅在用户上下文中被访问，那么无需关中断。
没有更多推荐了，博客访问： 63787
博文数量： 28
博客积分： 2510
博客等级： 少校
技术积分： 251
注册时间：
分类： LINUX 13:24:02
本文转自http://group.ednchina.com/.aspxspinlock和semaphore的差别和应用这两天经常有同事在问spinlock和semaphore的相关问题，什么时候该用spinlock？什么时候该用semaphore？什么时候该用spinlock_irq？什么时候该用spinlock_irqsave？的确，对于初涉内核开发的人员来说，spinlock和semaphore的应用是一个比较大的疑问。这里，我来谈谈我对这两个概念的想法吧。
Spinlock的实现机制可以描述如下：CPU首先将内存总线lock住，然后检测内存中的lock数据，如果数据为真，那么表示资源被人占用，无法获取。然后CPU会自璇检测该lock数据，直到数据不为真之后，lock该数据返回。在Linux中spinlock核心代码采用汇编语言实现，可以参考__raw_spin_lock函数。在2.6.25版本之后，Linux为了解决在多CPU平台上的不公平竞争，引入了排队自璇锁的算法。
说到这里，需要讲一下的是，spinlock在up平台上为空函数的说法。这个说法不是很严格，实际上在非强占的up平台上，spinlock的实现为空函数，在可抢占的up平台上，spinlock需要将抢占给disable掉，也就是说在spinlock的临界区，Linux无法抢占。在多CPU平台上，spinlock是有效的。
Semaphore的实现机制可以描述如下：CPU首先会检测信号量是否可获取，如果无法获取该信号量，那么就会导致一次上下文调度操作。从实现机制上来看，semaphore操作效率比较低，而spinlock的效率相对较高，但是这种效率的高低与应用相关，如果临界区操作的时间过长，那么采用spinlock会浪费大量的CPU时间，还不如做几次上下文调度释放CPU资源呢。所以，spinlock的应用有一个原则，那就是临界区操作尽可能的短，让CPU不要自璇太多的时间，这一点从spinlock的实现代码上也可以看出一些端倪，Linux开发人员着这个地方花费了好多心计。从上面的机制描述，我想可以总结出如下几点：
1、不允许睡眠的上下文需要采用spinlock，可以睡眠的上下文可以采用semaphore。在中断上下文中访问的竞争资源一定采用spinlock。
2、临界区操作较长的应用建议采用semaphore，临界区很短的操作建议采用spinlock。
3、需要关中断的场合需要调用spinlock_irq或者spinlock_irqsave，不明确当前中断状态的地方需要调用spinlock_irqsave，否则调用spinlock_irq。一个资源既在中断上下文中访问，又在用户上下文中访问，那么需要关中断，如果仅仅在用户上下文中被访问，那么无需关中断。
阅读(2445) | 评论(0) | 转发(1) |
给主人留下些什么吧！~~
请登录后评论。