c语言pv操作
1. 操作系统中P,V操作分别意味着要求什么
pv操作的含义：pv操作由p操作原语和v操作原语组成（原语是不可中断的过程），对信号量进行操作，具体定义如下：
p（s）：①将信号量s的值减1，即s=s-1；
②如果s³0，则该进程继续执行；否则该进程置为等待状态，排入等待队列。
v（s）：①将信号量s的值加1，即s=s+1；
②如果s>0，则该进程继续执行；否则释放队列中第一个等待信号量的进程。
pv操作的意义：我们用信号量及pv操作来实现进程的同步和互斥。pv操作属于进程的低级通信。
什么是信号量？信号量（semaphore）的数据结构为一个值和一个指针，指针指向等待该信号量的下一个进程。信号量的值与相应资源的使用情况有关。当它的值大于0时，表示当前可用资源的数量；当它的值小于0时，其绝对值表示等待使用该资源的进程个数。注意，信号量的值仅能由pv操作来改变。
一般来说，信号量s³0时，s表示可用资源的数量。执行一次p操作意味着请求分配一个单位资源，因此s的值减1；当s<0时，表示已经没有可用资源，请求者必须等待别的进程释放该类资源，它才能运行下去。而执行一个v操作意味着释放一个单位资源，因此s的值加1；若s£0，表示有某些进程正在等待该资源，因此要唤醒一个等待状态的进程，使之运行下去。
2. 用c语言实现PV操作生产者消费者关系
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
typedef HANDLE Semaphore; // 信号量的Windows原型
#define P(S) WaitForSingleObject(S, INFINITE) // 定义Windows下的P操作
#define V(S) ReleaseSemaphore(S, 1, NULL) // 定义Windows下的V操作
#define rate 1000
#define CONSUMER_NUM 10 /* 消费者个数 */
#define PRODUCER_NUM 10 /* 生产者个数 */
#define BUFFER_NUM 4 /* 缓冲区个数 */
char *thing[10] = ;
struct Buffer
{
int proct[BUFFER_NUM]; // 缓冲区
int start, end; // 两个指针
} g_buf;
Semaphore g_semBuffer, g_semProct, g_mutex;
// 消费者线程
DWORD WINAPI Consumer(LPVOID para)
{
// i表示第i个消费者
int i = *(int *)para;
int ptr; // 待消费的内容的指针
printf(" 猪头-%03d: 猪头我来啦！\n", i);
Sleep(300);
while (1)
{
printf(" 猪头-%03d: 我要吃.........!\n", i);
// 等待产品
P(g_semProct);
// 有产品，先锁住缓冲区 g_buf
P(g_mutex);
// 记录消费的物品
ptr = g_buf.start;
// 再移动缓冲区指针
g_buf.start = (g_buf.start+1)%BUFFER_NUM;
// 让其他消费者或生产者使用 g_buf
V(g_mutex);
printf(" 猪头-%03d: 我吃 buf[%d] = %s\n", i, ptr, thing[g_buf.proct[ptr]]);
Sleep(rate*rand()%10+110);
// 消费完毕，并释放一个缓冲
printf(" 猪头-%03d: 我爽了！ buf[%d] = %s\n", i, ptr, thing[g_buf.proct[ptr]]);
V(g_semBuffer);
}
return 0;
}
// 生产者线程
DWORD WINAPI Procer(LPVOID para)
{
int i = *(int *)para - CONSUMER_NUM;
int ptr;
int data; // 产品
printf("工作狂-%03d: 我来啦！\n", i);
Sleep(300);
while (1)
{
printf("工作狂-%03d: 我干干干…………\n", i);
Sleep(rate*rand()%10+110);
data = rand()%10;
printf("工作狂-%03d: 搞出一个东西 data = %s!\n", i, thing[data]);
// 等待存放空间
P(g_semBuffer);
// 有地方，先锁住缓冲区 g_buf
P(g_mutex);
// 记录消费的物品
ptr = g_buf.end;
// 再移动缓冲区指针
g_buf.end = (g_buf.end+1)%BUFFER_NUM;
// 让其他消费者或生产者使用 g_buf
V(g_mutex);
printf("工作狂-%03d: 搁到 buf[%d] = %s\n", i, ptr, thing[data]);
g_buf.proct[ptr] = data;
Sleep(rate/2*rand()%10+110);
// 放好了完毕，释放一个产品
printf("工作狂-%03d: buf[%d] = %s 放好了，大家吃！\n", i, ptr, thing[g_buf.proct[ptr]]);
V(g_semProct);
}
return 0;
}
int main(int argc, char *argv[])
{
// 线程技术，前面为消费者线程，后面为生产者线程
HANDLE hThread[CONSUMER_NUM+PRODUCER_NUM]; // 线程计数
//srand(time());
DWORD tid;
int i=0;
// 初始化信号量
g_mutex = CreateSemaphore(NULL, BUFFER_NUM, BUFFER_NUM, "mutexOfConsumerAndProcer");
g_semBuffer = CreateSemaphore(NULL, BUFFER_NUM, BUFFER_NUM, "BufferSemaphone");
g_semProct = CreateSemaphore(NULL, 0, BUFFER_NUM, "ProctSemaphone");
if ( !g_semBuffer || !g_semProct || !g_mutex)
{
printf("Create Semaphone Error!\n");
return -1;
}
int totalThreads = CONSUMER_NUM+PRODUCER_NUM;
// 开启消费者线程
printf("先请猪头们上席！\n");
for (i=0; i<CONSUMER_NUM; i++)
{
hThread[i] = CreateThread(NULL, 0, Consumer, &i, 0, &tid);
if ( hThread[i] ) WaitForSingleObject(hThread[i], 10);
}
printf("厨子们就位！\n");
for (; i<totalThreads; i++)
{
hThread[i] = CreateThread(NULL, 0, Procer, &i, 0, &tid);
if ( hThread[i] ) WaitForSingleObject(hThread[i], 10);
}
// 生产者和消费者的执行
WaitForMultipleObjects(totalThreads, hThread, TRUE, INFINITE);
return 0;
}
3. 用C语言编程实现P、V原语并用P、V原语哲学家就餐问题
这个是操作系统课的问题吧，我没做过哲学家这个程序，不过我用c语言做过生产者与消费者，大概差不多，pv操作时用windows api函数完成的。
4. 用C语言实现--生产者与消费者的问题(PV操作)
这个问题蛮好的
我给你个程序
给我加分啊
#include
<windows.h>
#include
<stdio.h>
#include
<stdlib.h>
typedef
HANDLE
Semaphore;
//
信号量的Windows原型
#define
P(S)
WaitForSingleObject(S,
INFINITE)
//
定义Windows下的P操作
#define
V(S)
ReleaseSemaphore(S,
1,
NULL)
//
定义Windows下的V操作
#define
rate
1000
#define
CONSUMER_NUM
10
/*
消费者个数
*/
#define
PRODUCER_NUM
10
/*
生产者个数
*/
#define
BUFFER_NUM
4
/*
缓冲区个数
*/
char
*thing[10]
=
{"猪脸",
"牛鞭",
"羊腰",
"驴蹄",
"狼心",
"狗肺",
"猴肝",
"老虎屁股",
"大象肚",
"河马大肠"};
struct
Buffer
{
int
proct[BUFFER_NUM];
//
缓冲区
int
start,
end;
//
两个指针
}
g_buf;
Semaphore
g_semBuffer,
g_semProct,
g_mutex;
//
消费者线程
DWORD
WINAPI
Consumer(LPVOID
para)
{
//
i表示第i个消费者
int
i
=
*(int
*)para;
int
ptr;
//
待消费的内容的指针
printf("
猪头-%03d:
猪头我来啦！\n",
i);
Sleep(300);
while
(1)
{
printf("
猪头-%03d:
我要吃.........!\n",
i);
//
等待产品
P(g_semProct);
//
有产品，先锁住缓冲区
g_buf
P(g_mutex);
//
记录消费的物品
ptr
=
g_buf.start;
//
再移动缓冲区指针
g_buf.start
=
(g_buf.start+1)%BUFFER_NUM;
//
让其他消费者或生产者使用
g_buf
V(g_mutex);
printf("
猪头-%03d:
我吃
buf[%d]
=
%s\n",
i,
ptr,
thing[g_buf.proct[ptr]]);
Sleep(rate*rand()%10+110);
//
消费完毕，并释放一个缓冲
printf("
猪头-%03d:
我爽了！
buf[%d]
=
%s\n",
i,
ptr,
thing[g_buf.proct[ptr]]);
V(g_semBuffer);
}
return
0;
}
//
生产者线程
DWORD
WINAPI
Procer(LPVOID
para)
{
int
i
=
*(int
*)para
-
CONSUMER_NUM;
int
ptr;
int
data;
//
产品
printf("工作狂-%03d:
我来啦！\n",
i);
Sleep(300);
while
(1)
{
printf("工作狂-%03d:
我干干干…………\n",
i);
Sleep(rate*rand()%10+110);
data
=
rand()%10;
printf("工作狂-%03d:
搞出一个东西
data
=
%s!\n",
i,
thing[data]);
//
等待存放空间
P(g_semBuffer);
//
有地方，先锁住缓冲区
g_buf
P(g_mutex);
//
记录消费的物品
ptr
=
g_buf.end;
//
再移动缓冲区指针
g_buf.end
=
(g_buf.end+1)%BUFFER_NUM;
//
让其他消费者或生产者使用
g_buf
V(g_mutex);
printf("工作狂-%03d:
搁到
buf[%d]
=
%s\n",
i,
ptr,
thing[data]);
g_buf.proct[ptr]
=
data;
Sleep(rate/2*rand()%10+110);
//
放好了完毕，释放一个产品
printf("工作狂-%03d:
buf[%d]
=
%s
放好了，大家吃！\n",
i,
ptr,
thing[g_buf.proct[ptr]]);
V(g_semProct);
}
return
0;
}
int
main(int
argc,
char
*argv[])
{
//
线程技术，前面为消费者线程，后面为生产者线程
HANDLE
hThread[CONSUMER_NUM+PRODUCER_NUM];
//
线程计数
//srand(time());
DWORD
tid;
int
i=0;
//
初始化信号量
g_mutex
=
CreateSemaphore(NULL,
BUFFER_NUM,
BUFFER_NUM,
"mutexOfConsumerAndProcer");
g_semBuffer
=
CreateSemaphore(NULL,
BUFFER_NUM,
BUFFER_NUM,
"BufferSemaphone");
g_semProct
=
CreateSemaphore(NULL,
0,
BUFFER_NUM,
"ProctSemaphone");
if
(
!g_semBuffer
||
!g_semProct
||
!g_mutex)
{
printf("Create
Semaphone
Error!\n");
return
-1;
}
int
totalThreads
=
CONSUMER_NUM+PRODUCER_NUM;
//
开启消费者线程
printf("先请猪头们上席！\n");
for
(i=0;
i<CONSUMER_NUM;
i++)
{
hThread[i]
=
CreateThread(NULL,
0,
Consumer,
&i,
0,
&tid);
if
(
hThread[i]
)
WaitForSingleObject(hThread[i],
10);
}
printf("厨子们就位！\n");
for
(;
i<totalThreads;
i++)
{
hThread[i]
=
CreateThread(NULL,
0,
Procer,
&i,
0,
&tid);
if
(
hThread[i]
)
WaitForSingleObject(hThread[i],
10);
}
//
生产者和消费者的执行
WaitForMultipleObjects(totalThreads,
hThread,
TRUE,
INFINITE);
return
0;
}
5. 自考操作系统pv操作可以用c语言实现吗 书上的我没学过，也不知道是...
很多课本用类pascal语言或者伪代码。
描述的时候是可以用C语言的。
明确告诉你，用伪代码描述就可以了。
PV操作的考试只考思想，不考具体实现。
跟语言完全无关。
6. 操作系统的pv操作是编程用的吗百度了很多，请大佬们用通俗的话讲一下，请不要复制粘贴，谢谢。
PV操作是信号量的一种，主要是用在生产者-消费者关系模型里，解决线程/进程并发和资源冲突的问题。在操作系统层面会提供相关的API用于信号量操作，如Windows C和Linux C下都有对应的信号量操作函数。某些编程语言如Java本身也提供信号量等并发机制，它也是依靠操作系统底层的这些API实现的。
7. c语言编写操作系统中有关进程的PV操作代码实现
电脑程序就是先执行什么后执行什么、毕竟是指令嘛、不像人我听着歌还可以做事，所以说同时执行一个功能几乎不行，除非你也可以调用、但是还是先执行什么后执行什么，相当于食堂吃饭排队一样的道理。windows下不是有很多dll文件嘛那就相当于桥梁做连接。
在c中有时间函数的time.h到计算就更简单了、写一个for循环、后面的条件为——。希望对你有帮助。