这篇文章参考了如下内容：
http://wenku.baidu.com/view/42a5704ccf84b9d528ea7ac0.html
http://wenku.baidu.com/view/71d778fafab069dc502201bc.html
http://zhwen.org/xlog/?p=165
http://blog.chinaunix.net/uid-21273878-id-1828718.html
http://blog.csdn.net/leves1989/article/details/3305609（详细介绍了PV操作）
PV操作
首先应弄清PV操作的含义：
PV操作由P操作原语和V操作原语组成（原语是不可中断的过程），对信号量进行操作，具体定义如下：
P（S）：
①将信号量S的值减1，即S=S-1；// 系统获得资源后的资源数目
②如果S>=0，表示系统中有资源存在，则该进程继续执行；否则该进程置为等待状态，排入等待队列。注意这儿是大于等于0，因为先进行了减1操作；
V（S）：
①将信号量S的值加1，即S=S+1；// 当前进程释放了一个资源
②如果S>0，则该进程继续执行；否则表示有其他进程在等待该资源，需要释放等待队列中等待信号量的进程，同时该进程继续执行。
【说明】这儿是大于0，说明现在系统中起码有一个资源，这儿为什么不执行一下调度程序，而是在资源S小于等于0调度呢？
因为在资源释放后大于0，说明系统中没有其他进程在等待该资源，则进程是没有权利进行调度的。
如果进程释放资源后，仍然是小于等于0，说明有多个进程在等待资源，这个时候就执行调度。
PV操作的意义：我们用信号量及PV操作来实现进程的同步和互斥。
PV操作属于进程的低级通信。
- 对于互斥操作——M个进程访问N个资源，且M>N，则需要进行互斥操作，即让有些进程进入等待队列，解决死锁问题；互斥的时候，只要设置一个信号量，赋于初值；
- 对于同步操作——A进程生产出东西给B进程用，A和B进程之间就要同步一下；同步的时候需要设置两个信号量在A和B之间同步处理；
信号量（semaphore）的数据结构为一个值和一个指针，指针指向等待该信号量的下一个进程。信号量的值与相应资源的使用情况有关。
当它的值大于0时，表示当前可用资源的数量；
当它的值小于0时，其绝对值表示等待使用该资源的进程个数。注意，信号量的值仅能由PV操作来改变。
一般来说，信号量S表示可用资源的数量。执行一次P操作意味着请求分配一个单位资源，因此S的值减1；当S<=0时，表示已经没有可用资源，请求者必须等待别的进程释放该类资源，它才能运行下去。而执行一个V操作意味着释放一个单位资源，因此S的值加1；若S<=0，表示有某些进程正在等待该资源，因此要唤醒一个等待状态的进程，使之运行下去。
利用信号量和PV操作实现进程互斥的一般模型是：
进程P1 进程P2 …… 进程Pn
…… …… ……
P（S）； P（S）； P（S）；
临界区； 临界区； 临界区；
V（S）； V（S）； V（S）；
…… …… …… ……
其中信号量S用于互斥，初值为1。
使用PV操作实现进程互斥时应该注意的是：
（1）每个程序中用户实现互斥的P、V操作必须成对出现，先做P操作，进临界区，后做V操作，出临界区。若有多个分支，要认真检查其成对性。
（2）P、V操作应分别紧靠临界区的头尾部，临界区的代码应尽可能短，不能有死循环。
（3）互斥信号量的初值一般为1。
【例1】生产者-消费者问题
在多道程序环境下，进程同步是一个十分重要又令人感兴趣的问题，而生产者-消费者问题是其中一个有代表性的进程同步问题。下面我们给出了各种情况下的生产者-消费者问题，深入地分析和透彻地理解这个例子，对于全面解决操作系统内的同步、互斥问题将有很大帮助。
（1）一个生产者，一个消费者，公用一个缓冲区。
定义两个同步信号量：
empty——表示缓冲区是否为空，初值为1。
full——表示缓冲区中是否为满，初值为0。
生产者进程
while(TRUE){
生产一个产品;
P(empty);
产品送往Buffer;
V(full);
}消费者进程
while(True){
P(full);
从Buffer取出一个产品;
V(empty);
消费该产品;
}（2）一个生产者，一个消费者，公用n个环形缓冲区。
定义两个同步信号量：
empty——表示缓冲区是否为空，初值为n。
full——表示缓冲区中是否为满，初值为0。
设缓冲区的编号为1～n-1，定义两个指针in和out，分别是生产者进程和消费者进程使用的指针，指向下一个可用的缓冲区。
生产者进程
while(TRUE){
生产一个产品;
P(empty);
产品送往buffer（in）；
in=(in+1)mod n；
V(full);
}
消费者进程
while(TRUE){
P(full);
从buffer（out）中取出产品；
out=(out+1)mod n；
V(empty);
消费该产品;
}
（3）一组生产者，一组消费者，公用n个环形缓冲区
在这个问题中，不仅生产者与消费者之间要同步，而且各个生产者之间、各个消费者之间还必须互斥地访问缓冲区。
定义四个信号量：
empty——表示缓冲区是否为空，初值为n。
full——表示缓冲区中是否为满，初值为0。
mutex1——生产者之间的互斥信号量，初值为1。
mutex2——消费者之间的互斥信号量，初值为1。
设缓冲区的编号为1～n-1，定义两个指针in和out，分别是生产者进程和消费者进程使用的指针，指向下一个可用的缓冲区。
生产者进程
while(TRUE){
生产一个产品;
P(empty);
P(mutex1)；
产品送往buffer（in）；
in=(in+1)mod n；
V(mutex1);
V(full);
}消费者进程
while(TRUE){
P(full)
P(mutex2)；
从buffer（out）中取出产品；
out=(out+1)mod n；
V（mutex2）；
V(empty);
消费该产品;
}
需要注意的是无论在生产者进程中还是在消费者进程中，两个P操作的次序不能颠倒。应先执行同步信号量的P操作，然后再执行互斥信号量的P操作，否则可能造成进程死锁。
【说明】为什么要先执行同步信号量P，再执行互斥信号量P呢？
【例2】桌上有一空盘，允许存放一只水果。爸爸可向盘中放苹果，也可向盘中放桔子，儿子专等吃盘中的桔子，女儿专等吃盘中的苹果。规定当盘空时一次只能放一只水果供吃者取用，请用P、V原语实现爸爸、儿子、女儿三个并发进程的同步。
分析 在本题中，爸爸、儿子、女儿共用一个盘子，盘中一次只能放一个水果。当盘子为空时，爸爸可将一个水果放入果盘中。若放入果盘中的是桔子，则允许儿子吃，女儿必须等待；若放入果盘中的是苹果，则允许女儿吃，儿子必须等待。本题实际上是生产者-消费者问题的一种变形。这里，生产者放入缓冲区的产品有两类，消费者也有两类，每类消费者只消费其中固定的一类产品。
解：在本题中，应设置三个信号量S、So、Sa，信号量S表示盘子是否为空，其初值为l；信号量So表示盘中是否有桔子，其初值为0；信号量Sa表示盘中是否有苹果，其初值为0。同步描述如下：
int S＝1;
int Sa＝0;
int So＝0;
main()
{
cobegin
father(); /*父亲进程*/
son(); /*儿子进程*/
daughter(); /*女儿进程*/
coend
｝
father()
{
while(1)
{
P(S);
将水果放入盘中;
if（放入的是桔子）V(So);
else V(Sa);
}
}
son()
{
while(1)
{
P(So);
从盘中取出桔子;
V(S);
吃桔子;
｝
}
daughter()
{
while(1)
{
P(Sa);
从盘中取出苹果;
V(S);
吃苹果;
｝
｝
【例3】 桌上有一空盘，允许存放2只水果。爸爸可向盘中放苹果，妈妈可向盘中放桔子，儿子专等吃盘中的桔子，女儿专等吃盘中的苹果，请用P、V原语实现爸爸、妈妈、儿子、女儿三个并发进程的同步。
解：
这是一个同步问题，果盘不存在互斥操作，对于同步，需要至少2个信号量处理，这道题目
同步历程如下：
long S = 2;
long So = 0;
long Sa = 0;
void main
{
cobegin
father();
mather();
son();
daughter();
coend
}
father()
{
while(1)
{
P(S)
放苹果
V（Sa）
}
}
mather()
{
while(1)
{
P(S)
放桔子
V（So）
}
}
son()
{
while(1)
{
P(So)
吃桔子
V（S）
}
}
daughter()
{
while(1)
{
P(Sa)
吃苹果
V（S）
}
}
继续上面的这个例子：
如果对水果盘设置互斥信号，即某个时刻只允许一个人访问水果盘，则系统中需要添加互斥访问变量mutex，初值设置为1，这个时候的例程修改为：
什么是信号量
信号量的使用主要是用来保护共享资源，使得资源在一个时刻只有一个进程（线程）所拥有。
信号量的值为正的时候，说明它空闲。所测试的线程可以锁定而使用它。若为0，说明它被占用，测试的线程要进入睡眠队列中，等待被唤醒。
信号量的分类Linux提供三种信号量：
（1） 内核信号量，由内核控制路径使用
（2） 用户态进程使用的信号量，这种信号量又分为POSIX信号量和SYSTEM V信号量。
内核信号量为了同步对内核共享资源的访问，内核提供了down 函数和up 函数用于获取和释放资源。down 和up 所保护的访问资源的内核代码区域，就构成一个临界区。在等待获取资源进入临界区的过程中，代表进程运行的内核控制路径可以睡眠。
因此，简单理解：系统利用down和up实现了教科书中的PV操作。
内核信号量类似于自旋锁，因为当锁关闭着时，它不允许内核控制路径继续进行。然而，当内核控制路径试图获取内核信号量锁保护的忙资源时，相应的进程就被挂起。只有在资源被释放时，进程才再次变为可运行。 只有可以睡眠的函数才能获取内核信号量；中断处理程序和可延迟函数都不能使用内核信号量。为什么呢？因为内核信号量是这么定义的：
struct semaphore {
atomic_t count; // 资源计数
int sleepers; // 表示是否有进程在信号量上睡眠（两个地方描述不一致，有的没有这个变量）
wait_queue_head_t wait; // 当前等待睡眠的队列头指针
}
我在另外一份网页上看到semaphore的定义是这样的：
定义信号量：下面代码定义名为sem的信号量。
struct semaphore sem;
struct semaohore结构体在内核中定义如下，在/include/linux/semaphore.h目录下：
struct semaphore{
spinlock_t lock; // 为什么要自旋锁呢？因为对信号量的操作离不开锁装置；
unsigned int count; // 记录当前进程在信号量上的睡眠个数
struct list_head wait_list; // 睡眠队列
};
内核信号量可以理解为是一种睡眠锁！ 内核信号量的操作
- 当进程需要获取信号量时，它调用down函数进入临界区。down将semphore的count字段减1，若count非负，则可进入临界区；否则，加入睡眠队列。
- 当进程离开临界区时，它调用up函数。up将semphore的count字段加1，若count非正，表示有进程睡眠，则将进程从wait等待队列中移走并唤醒它。
内核信号量的PV操作
初始化信号量
在/include/linux/semaphore.h目录下，
void sema_init(struct semaphore* sem, int val)
函数用于初始化信号量并设置信号量sem的值为val。尽管信号量可以被初始化为大于1的值从而成为一个计数信号量，但是它通常不被这样使用。
内核定义了两个宏来把sem的值设置为1或者0。
#define init_MUTEX(sem) sema_init(sem, 1)
#define init_MUTEX_LOCKED(sem) sema_init(sem, 0)
使用init_MUTEX(sem) 初始化信号量时，表示信号量最初是可以被获取的。
而使用init_MUTEX_LOCKED(sem) 初始化信号量时，此信号量只有先被释放才可以获取。
信号量的P操作——down
获取信号量
void down(struct semaphore *sem);
该函数用于获取信号量sem，它会导致睡眠，因此不能在中断上下文使用。
在内核里该函数的源代码如下：在kernel/semaphore.c文件里：
void down(struct semaphore *sem)
{
unsigned long flags;
spin_lock_irqsave(&sem->lock, flags);
if (likely(sem->count > 0))
sem->count--;
else
__down(sem);
spin_unlock_irqrestore(&sem->lock, flags);
}
这里重点看if (likely(sem->count > 0))，这句话表示当获取信号量成功时，就执行sem->count--; 即对信号量的值减一。else表示获取信号量失败，此时调用__down函数进入睡眠状态，并将此进程插入到等待队列尾部。
内核定义了信号量的等待队列结构体：
获取信号量down的另外一种定义方式：
int down_interruptible(struct semaphore *sem);
该函数功能与down()类似，不同之处是，down()在获取信号量失败进入睡眠状态时的进程是不能被打断的，而down_interruptible()在进入睡眠状态时的进程能被信号打断，信号也会导致函数返回。下面我们也来看一看这个函数的源码：在kernel/semaphore.c文件里：
int down_interruptible(struct semaphore *sem)
{
unsigned long flags;
int result = 0;
spin_lock_irqsave(&sem->lock, flags);
if (likely(sem->count > 0))
sem->count--;
else
result = __down_interruptible(sem);
spin_unlock_irqrestore(&sem->lock, flags);
return result;
}
这里还有一个问题：在获取信号量失败后，为什么down不能被中断，而down_interruptible却可以被中断呢？我们从down和down_interruptible的源代码可以得知，在获取信号量失败后，down函数运行了__down函数，而down_interruptible函数运行了__down_interruptible。
在__down函数里，是把进程的状态设置为TASK_UNINTERRUPTIBLE ，即不可中断状态。
在__down_interruptible里，是把进程的状态设置为TASK_INTERRUPTIBLE ，即可中断状态。这就解释了以上提出的问题。
释放信号量
void up(struct semaphore *sem);
该函数用于释放信号量sem,唤醒等待者。
它的源代码如下：
void up(struct semaphore *sem)
{
unsigned long flags;
spin_lock_irqsave(&sem->lock, flags);
if (likely(list_empty(&sem->wait_list)))
sem->count++;
else
__up(sem);
spin_unlock_irqrestore(&sem->lock, flags);
}
up函数首先判断等待队列是否为空，如果是空的话，就执行sem->count++;否则，执行__up()函数，释放掉等待队列尾部的信号量。
信号量示例代码
#include <linux/init.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/sem.h>
struct semaphore sem1;
struct semaphore sem2;
int num[2][5] = {
{0,2,4,6,8},
{1,3,5,7,9}
};
int thread_one(void *p);
int thread_two(void *p);
int thread_one(void *p)
{
int *num = (int *)p;
int i;
for(i = 0; i < 5; i++){
down(&sem1); //获取信号量1
printk("%d ", num[i]);
up(&sem2); //释放信号量2
}
return 0;
}
int thread_two(void *p)
{
int *num = (int *)p;
int i;
for(i = 0; i < 5; i++){
down(&sem2); //获取信号量2
printk("%d ", num[i]);
up(&sem1); //释放信号量1
}
return 0;
}
static int lan_init(void)
{
printk("lan is coming\n");
init_MUTEX(&sem1); //初始化信号量1， 使信号量1最初可被获取
init_MUTEX_LOCKED(&sem2); //初始化信号量2，使信号量2只有被释放后才可被获取
kernel_thread(thread_one, num[0], CLONE_KERNEL);
kernel_thread(thread_two, num[1], CLONE_KERNEL);
return 0;
}
static void lan_exit(void)
{
printk("\nlan exit\n");
}
module_init(lan_init);
module_exit(lan_exit);