在Linux环境下使用C语言进行编程，题目要求如下

nt S=1//S 表示盘子是否为空；

int Sa=0//Sa表示盘中是否有苹果；

int Sb=0//Sb表示盘中是否有桔子；

父亲

while(TRUE)

{

Wait(S)

将水果放入盘中

if (

放入的是桔子

)

Signal(Sb)

Else

Signal(Sa)

}

儿子

while(TRUE)

{

Wait(Sb)

从盘中取出桔子；

Signal(S)

吃桔子

}

女儿

while(TRUE)

{

Wait(Sa)

从盘中取出苹果；

Signal(S)

吃苹果

}

//算法描述语言使用基于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

}

---