pv操作c语言
‘壹’ 用c语言编程实现P、V原语并用P、V原语哲学家就餐问题
这个是操作系统课的问题吧，我没做过哲学家这个程序，不过我用c语言做过生产者与消费者，大概差不多，pv操作时用windows api函数完成的。
‘贰’ c语言指令有哪些啊
第一章：绪论？
内核版本号格式：x.y.zz-www／x为主版本号，y为次版本号，zz为次次版本号，www为发行号／次版本号改变说明内核有重大变革，其偶数为稳定版本，奇数为尚在开发中的版本
第二章：基础？
文件种类：-：txt，二进制／d：目录／l：链接文件（link）／b：区块设备文件／c：字符设备文件／p：管道
目录结构：bin：可执行／boot：开机引导／dev：设备文件／etc：系统配置文件／lib：库文件／mnt：设备挂载点／var：系统日志／
命令：rmdir：删除空目录／find [path] [expression]／touch命令还可以修改指定文件的最近一次访问时间／tar -czvf usr.tar.gz path／tar –zxvf usr.tar.gz／tar –cjvf usr.tar.bz2 path／tar –jxvf usr.tar.bz2
gcc：预处理：-g／I在头文件搜索路径中添加目录，L在库文件搜索路径中
gdb：设置断点：b／查看断点信息：info
Makefile：make –f other_makefile／<：第一个依赖文件的名称／@：目标文件的完整名称／^：所有不重复的依赖文件／+：所有依赖文件（可能重复）
第三章：文件IO
read：read(fd, temp, size); ／读fd中长度为size的值到temp／返回0表示file为NULL
write：write(fd, buf, buf_size); ／写长度为buf_size的buf内容到fd中
lseek：lseek(fd, offset, SEEK_SET); ／从文件开头向后增加offset个位移量
unlink：从文件系统中删除一个名字
open1：int open(const char * pathname, int flags, mode_t mode);／flags为读写方式／mode为权限设置／O_EXCL：测试文件是否存在／O_TRUNC：若存在同名文件则删除之并新建
open2：注意O_NONBLOCK
mmap.1：void *mmap(void *start, size_t length, int prot, int flags, int fd, off_t offsize);
mmap.2：mmap(start_addr, flength, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
fcntl：上锁／int fcntl(int fd, int cmd, struct flock * lock);／对谁；做什么；设置所做内容
select：fd_max+1，回传读状况，回传写状况，回传异常，select等待的时间／NULL为永远等待／0为从不等待／凡需某状况则用之，反则(fd_set *)NULL之
FD_*那几个函数……
一般出错则返回-1
第四章：文件与目录
硬链接与符号链接？
chdir改变目录
0：in／1：out／2：err
第五章：内存管理
可执行文件存储时：代码区、数据区和未初始化区
栈：by编译器，向低址扩展，连续，效率高／堆：by程序员
/etc/syslog.conf，系统log记录文件／优先级为-20时最高
第六章：进程和信号
程序代码、数据、变量、文件描述符和环境／init的pid为1
execl族：int execl(const char * path, const char * arg, ....);／path即可执行文件的路径，一般为.／最后一个参数以NULL结束
waitpid：waitpid(pid_t pid,int * status,int options);／option：一般用WNOHANG，没有已经结束的子进程则马上返回，不等待
kill：int kill(pid_t pid,int sig);／发送信号sig给pid
void (*signal(int signum, void(* handler)(int)))(int);／第一个参数被满足时，执行handler／第一个参数常用：SIG_IGN：忽略信号／SIG_DFL：恢复默认信号
第七章：线程
sem_init(sem_t *sem, int pshared, unsigned int value)／pshared为0／value即初始值
第八章：管道
1：write／0：read
第九章：信号量、共享内存和消息队列
临界资源：操作系统中只允许一个进程访问的资源／临界区：访问临界资源的那段代码
信号量：建立联系（semget），然后初始化，PV操作，最后destroy
共享内存没有提供同步机制
第十章：套接字
UDP：无连接协议，无主客端的区分／实时性
TCP：字节流／数据可靠性／网络可靠性
数据报：SOCK_STREAM／SOCK_DGRAM
其它
管道一章的both_pipe即父子进程间的全双工管道通讯
关系到信号和互斥的服务器-客户端程序
线程一章的class的multi_thread文件夹下的thread8.c
int main(void)
{
int data_processed;
int file_pipes_1[2];
int file_pipes_2[2];
char buffer[BUFSIZ + 1];
const char some_data[] = "123";
const char ch2p[] = "this is the string from child to the parent!";
const char p2ch[] = "this is the string from parent to the child!";
pid_t fork_result;
memset(buffer,'\0',sizeof(buffer));
if(pipe(file_pipes_1) == 0){
if(pipe(file_pipes_2) == 0){
fork_result = fork();
switch(fork_result){
case -1:
perror("fork error");
exit(EXIT_FAILURE);
case 0://child
close(file_pipes_1[1]);
close(file_pipes_2[0]);
printf("in the child!\n");
read(file_pipes_1[0],buffer, BUFSIZ);
printf("in the child, read_result is \"%s\"\n",buffer);
write(file_pipes_2[1],ch2p, sizeof(ch2p));
printf("in the child, write_result is \"%s\"\n",ch2p);
exit(EXIT_SUCCESS);
default://parent
close(file_pipes_1[0]);
close(file_pipes_2[1]);
printf("in the parent!\n");
write(file_pipes_1[1], p2ch, sizeof(p2ch));
printf("in the parent, write_result is \"%s\"\n",p2ch);
read(file_pipes_2[0],buffer, BUFSIZ);
printf("in the parent, read_result is \"%s\"\n",buffer);
exit(EXIT_SUCCESS);
}
}
}
}
#ifndef DBG
#define DBG
#endif
#undef DBG
#ifdef DBG
#define PRINTF(fmt, args...) printf("file->%s line->%d: " \
fmt, __FILE__, __LINE__, ##args)
#else
#define PRINTF(fmt, args...) do{}while(0);
#endif
int main(void)
{
PRINTF("%s\n", "hello!");
fprintf(stdout, "hello hust!\n");
return 0;
}
#define N 5
#define MAX 5
int nput = 0;
char buf[MAX][50];
char *buffer = "";
char buf_r[100];
sem_t mutex,full,avail;
void *proctor(void *arg);
void *consumer(void *arg);
int i = 0;
int main(int argc, char **argv)
{
int cnt = -1;
int ret;
int nput = 0;
pthread_t id_proce[10];
pthread_t id_consume;
ret = sem_init(&mutex, 0, 1);
ret = sem_init(&avail, 0, N);
ret = sem_init(&full, 0, 0);
for(cnt = 0; cnt < 6; cnt ++ ){
//pthread_create(&id_proce[cnt], NULL, (void *)proctor, &cnt);
pthread_create(&id_proce[cnt], NULL, (void *)proctor, (void *)cnt);
}
pthread_create(&id_consume, NULL, (void *)consumer, NULL);
for(cnt = 0; cnt < 6; cnt ++){
pthread_join(id_proce[cnt], NULL);
}
pthread_join(id_consume,NULL);
sem_destroy(&mutex);
sem_destroy(&avail);
sem_destroy(&full);
exit(EXIT_SUCCESS);
}
void *proctor(void *arg)
{
while(1){
sem_wait(&avail);
sem_wait(&mutex);
if(nput >= MAX * 3){
sem_post(&avail);
//sem_post(&full);
sem_post(&mutex);
return NULL;
}
sscanf(buffer + nput, "%s", buf[nput % MAX]);
//printf("write[%d] \"%s\" to the buffer[%d]\n", (*(int*)arg), buf[nput % MAX],nput % MAX);
printf("write[%d] \"%s\" to the buffer[%d]\n", (int)arg, buf[nput % MAX],nput % MAX);
nput ++;
printf("nput = %d\n", nput);
sem_post(&mutex);
sem_post(&full);
}
return NULL;
}
void *consumer(void *arg)
{
int nolock = 0;
int ret, nread, i;
for(i = 0; i < MAX * 3; i++)
{
sem_wait(&full);
sem_wait(&mutex);
memset(buf_r, 0, sizeof(buf_r));
strncpy(buf_r, buf[i % MAX], sizeof(buf[i % MAX]));
printf("read \"%s\" from the buffer[%d]\n\n",buf_r, i % MAX);
sem_post(&mutex);
sem_post(&avail);
//sleep(1);
}
return NULL;
}
‘叁’ 用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;
}
‘肆’ 用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;
}
‘伍’ linux中pv操作伪代码怎么写
//算法描述语言使用基于C语言的伪代码
//算法思想：根据楼主的要求“为防止数的丢失和重复取同一个数”可以看出，进程A、进程B、进程C三者之间应该是互斥的关系。那么问题所限定的使用带埋信号量的方式来管理的潜藏意思，就是要利用PV
原语实现并发进程在资源争夺中拆薯有效互斥。
//而具体实现的目标是“防止数旅行者的丢失”和“重复取同一个数”。由于本人不才，只讨论单任务系统下的状况。
//“数的丢失”的情况主要是进程A产生了随即变量给F后，但在进程B或者进程C处理之前又获得处理机的使用权而覆盖了之前那个未被处理过的F中的数——进程A连续获得处理机的使用权，而进程B、进