linux中pv *** 作伪代码怎么写

//算法描述语言使用基于C语言的伪代码//算法思想：根据楼主的要求“为防止数的丢失和重复取同一个数”可以看出，进程A、进程B、进程C三者之间应该是互斥的关系。那么问题所限定的使用信号量的方式来管理的潜藏意思，就是要利用PV 原语实现并发进程在资源争夺中有效互斥。//而具体实现的目标是“防止数的丢失”和“重复取同一个数”。由于本人不才，只讨论单任务系统下的状况。//“数的丢失”的情况主要是进程A产生了随即变量给F后，但在进程B或者进程C处理之前又获得处理机的使用权而覆盖了之前那个未被处理过的F中的数——进程A连续获得处理机的使用权，而进程B、进

#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 product[BUFFER_NUM] // 缓冲区

int start, end // 两个指针

} g_buf

Semaphore g_semBuffer, g_semProduct, 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_semProduct)

// 有产品，先锁住缓冲区 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.product[ptr]])

Sleep(rate*rand()%10+110)

// 消费完毕，并释放一个缓冲

printf(" 猪头-%03d: 我爽了！ buf[%d] = %s\n", i, ptr, thing[g_buf.product[ptr]])

V(g_semBuffer)

}

return 0

}

// 生产者线程

DWORD WINAPI Producer(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.product[ptr] = data

Sleep(rate/2*rand()%10+110)

// 放好了完毕，释放一个产品

printf("工作狂-%03d: buf[%d] = %s 放好了，大家吃！\n", i, ptr, thing[g_buf.product[ptr]])

V(g_semProduct)

}

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, "mutexOfConsumerAndProducer")

g_semBuffer = CreateSemaphore(NULL, BUFFER_NUM, BUFFER_NUM, "BufferSemaphone")

g_semProduct = CreateSemaphore(NULL, 0, BUFFER_NUM, "ProductSemaphone")

if ( !g_semBuffer || !g_semProduct || !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, Producer, &i, 0, &tid)

if ( hThread[i] ) WaitForSingleObject(hThread[i], 10)

}

// 生产者和消费者的执行

WaitForMultipleObjects(totalThreads, hThread, TRUE, INFINITE)

return 0

}

这个问题蛮好的

我给你个程序

给我加分啊

#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

product[BUFFER_NUM]

//

缓冲区

int

start,

end

//

两个指针

}

g_buf

Semaphore

g_semBuffer,

g_semProduct,

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_semProduct)

//

有产品，先锁住缓冲区

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.product[ptr]])

Sleep(rate*rand()%10+110)

//

消费完毕，并释放一个缓冲

printf("

猪头-%03d:

我爽了！

buf[%d]

=

%s\n",

i,

ptr,

thing[g_buf.product[ptr]])

V(g_semBuffer)

}

return

0

}

//

生产者线程

DWORD

WINAPI

Producer(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.product[ptr]

=

data

Sleep(rate/2*rand()%10+110)

//

放好了完毕，释放一个产品

printf("工作狂-%03d:

buf[%d]

=

%s

放好了，大家吃！\n",

i,

ptr,

thing[g_buf.product[ptr]])

V(g_semProduct)

}

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,

"mutexOfConsumerAndProducer")

g_semBuffer

=

CreateSemaphore(NULL,

BUFFER_NUM,

BUFFER_NUM,

"BufferSemaphone")

g_semProduct

=

CreateSemaphore(NULL,

0,

BUFFER_NUM,

"ProductSemaphone")

if

(

!g_semBuffer

||

!g_semProduct

||

!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,

Producer,

&i,

0,

&tid)

if

(

hThread[i]

)

WaitForSingleObject(hThread[i],

10)

}

//

生产者和消费者的执行

WaitForMultipleObjects(totalThreads,

hThread,

TRUE,

INFINITE)

return

0

}

---