linux PV操作理解

进程通常分为就绪、运行和阻塞三个工作状态。三种状态在某些条件下可以转换，三者之间的转换关系如下：



进程三个状态之间的转换就是靠PV操作来控制的。PV操作主要就是P操作、V操作和信号量。其中信号量起到了至关重要的作用。

信号量

信号量是最早出现的用来解决进程同步与互斥问题的机制。　

信号量（Saphore）由一个值和一个指针组成，指针指向等待该信号量的进程。信号量的值表示相应资源的使用情况。信号量S>=0时，S表示可用资源的数量。执行一次P操作意味着请求分配一个资源，因此S的值减1；当S<0时，表示已经没有可用资源，S的绝对值表示当前等待该资源的进程数。请求者必须等待其他进程释放该类资源，才能继续运行。而执行一个V操作意味着释放一个资源，因此S的值加1；若S<0，表示有某些进程正在等待该资源，因此要唤醒一个等待状态的进程，使之运行下去。

注意，信号量的值只能由PV操作来改变。
　　

　

关于PV操作容易产生的一些疑问：

1，S大于0那就表示有临界资源可供使用，为什么不唤醒进程？

S大于0的确表示有临界资源可供使用，也就是说这个时候没有进程被阻塞在这个资源上，所以不需要唤醒。

2，S小于0应该是说没有临界资源可供使用，为什么还要唤醒进程？

V原语操作的本质在于：一个进程使用完临界资源后，释放临界资源，使S加1，以通知其它的进程，这个时候如果S<0，表明有进程阻塞在该类资源上，因此要从阻塞队列里唤醒一个进程来“转手”该类资源。比如，有两个某类资源，四个进程A、B、C、D要用该类资源，最开始S=2，当A进入，S=1，当B进入S=0，表明该类资源刚好用完， 当C进入时S=-1，表明有一个进程被阻塞了，D进入，S=-2。当A用完该类资源时，进行V操作，S=-1，释放该类资源，因为S<0，表明有进程阻塞在该类资源上，于是唤醒一个。

3，如果是互斥信号量的话，应该设置信号量S=1，但是当有5个进程都访问的话，最后在该信号量的链表里会有4个在等待，也是说S=-4，那么第一个进程执行了V操作使S加1，释放了资源，下一个应该能够执行，但唤醒的这个进程在执行P操作时因S<0，也还是执行不了，这是怎么回事呢？

当一个进程阻塞了的时候，它已经执行过了P操作，并卡在临界区那个地方。当唤醒它时就立即进入它自己的临界区，并不需要执行P操作了，当执行完了临界区的程序后，就执行V操作。

4，S的绝对值表示等待的进程数，同时又表示临界资源，这到底是怎么回事？

当信号量S小于0时，其绝对值表示系统中因请求该类资源而被阻塞的进程数目.S大于0时表示可用的临界资源数。注意在不同情况下所表达的含义不一样。当等于0时，表示刚好用完。

关于pv操作部分的内容，其实算不上什么新的东西。但是它对于我们理解信号量、消息处理部分的工作还是有很大帮助的。之前我们给出了一个win32的处理方案，但是实现的比较草率。所以我们今天可以利用linux上的信号量函数把这个功能重新实现一遍。

（1）linux下面信号量的基本函数

a）创建信号量 sem_init

b）等待信号量 sem_wait

c）释放信号量 sem_pos

d）删除信号量 sem_destroy

（2）编写pv操作函数

之前在编写pv操作的时候，没有考虑到消息处理的时序问题，所以在某些极端的情况下可能会造成一些问题。所以本次pv操作采用了循环队列的形式，保持了消息的先后入队顺序。这样对于线程收到的各种消息就可以依次进行处理解决了。同样，我们文件编译的方法非常简单，shell下输入gcc sem.c -g -o sem -lpthread即可。

可能有同学会问，单独的循环队列和pv操作处理上有什么差别？其实差别很简单，pv可以是不同线程向一个线程发送消息，而循环队列只能接受一个线程发送的消息，否则处理上就麻烦了。

[cpp] view
plain copy

#include <stdio.h>

#include <malloc.h>

#include <string.h>

#include <pthread.h>

#include <semaphore.h>

struct MSG

{

sem_t s_empty;

sem_t s_full;

sem_t s_msg;

int* p_buffer;

int start;

int end;

int count;

};

#define STATUS int

#define TRUE 1

#define FALSE 0

static struct MSG* p_msg = NULL;

struct MSG* alloc_msg(int count)

{

struct MSG* p_msg;

p_msg = (struct MSG*) malloc(sizeof(struct MSG));

if(NULL == p_msg)

{

goto error1;

}

memset(p_msg, 0, sizeof(struct MSG));

p_msg->count = count;

p_msg->p_buffer = (int*)malloc(sizeof(int)* count);

if(NULL == p_msg->p_buffer)

{

goto error2;

}

sem_init(&p_msg->s_empty, 0, count);

sem_init(&p_msg->s_full, 0, 0);

sem_init(&p_msg->s_msg, 0, 1);

return p_msg;

error2:

free(p_msg);

error1:

return;

}

void del_msg(struct MSG* p_msg)

{

if(p_msg)

{

if(p_msg->p_buffer)

{

free(p_msg->p_buffer);

}

sem_destroy(&p_msg->s_msg);

sem_destroy(&p_msg->s_full);

sem_destroy(&p_msg->s_empty);

free(p_msg);

}

}

STATUS put_msg(struct MSG* p_msg, int data)

{

if(NULL == p_msg )

{

return FALSE;

}

sem_wait(&p_msg->s_empty);

sem_wait(&p_msg->s_msg);

p_msg->p_buffer[p_msg->start] = data;

p_msg->start = (p_msg->start + 1) % p_msg->count;

sem_post(&p_msg->s_msg);

sem_post(&p_msg->s_full);

return TRUE;

}

STATUS get_msg(struct MSG* p_msg, int* p_buf)

{

if(NULL == p_msg || NULL == p_buf)

{

return FALSE;

}

sem_wait(&p_msg->s_full);

sem_wait(&p_msg->s_msg);

p_buf[0] = p_msg->p_buffer[p_msg->end];

p_msg->end = (p_msg->end + 1)% p_msg->count;

sem_post(&p_msg->s_msg);

sem_post(&p_msg->s_empty);

return TRUE;

}

void* set_func(void* args)

{

int index = 100;

while(1)

{

put_msg(p_msg, index);

printf("set %d\n", index);

index ++; sleep(1);

}

return NULL;

}

void* get_func(void* args)

{

int data;

while(1)

{

get_msg(p_msg, &data);

printf("get %d\n", data);

sleep(1);

}

return NULL;

}

int main(int argc, char* argv[])

{

pthread_t pid1, pid2;

int index;

p_msg = alloc_msg(10);

if(NULL == p_msg)

{

goto end;

}

if(pthread_create(&pid1, NULL, set_func, NULL))

{

goto end;

}

if(pthread_create(&pid2, NULL, get_func, NULL))

{

goto end;

}

while(1)

{

sleep(0);

}

end:

return 1;

}