Unix下读者写者同步问题的模拟程序

p { margin-bottom: 0.21cm; }

/*

*
ReaderWriter.c

*

题目

:2

：

*
Unix

下读者写者同步问题的模拟程序
要求

4

个读进程

2

个写进程。

*

采用信号量方式实现。可以采用

Pthread

多线程编程。

*

*
Created on: 2011-1-17

*
Author: banxi1988

*

*

信号量通信机制主要用来实现进程间同步

,

信号
量值用来标识系统可用 资源的个数

*

例如可以使用信号号来标识一个缓冲区空间的大小

,(

假定缓冲区空间大小为

256

个字节

.

*

在没有使用之前

,

该缓冲区没有任何内容

,

可用资源为

256,

即可以初始化信号
量为

256,

*

每向缓冲区写入一个字符

,

信号量的值自动减

1,

当信号量的值为

0

时

,

即表示缓冲区满

.

*

资源暂不可用

.

每从缓冲区读出一个字符

,

信号
时自动加

1,

如果信号量的值为

256,

则表示

*

缓冲区中没有内容

,

不可读

.

*

信号量初始化函数参考

:

*
// Initialize semaphore object SEM to VALUE. If PSHARED then
share it

//
with other processes.

extern

int

sem_init (sem_t *__sem,

int

__pshared, unsigned

int

__value)

简单翻译如下

,

将信号量对象

SEM

初始化为

VALUE

值

,

当信号量的值达到

PSHARED

时

,

将其分享给其它进程

.

*/

#include

<stdio.h>

#include

<stdlib.h>

#include

<unistd.h>

#include

<pthread.h>

#include

<time.h>

#include

<semaphore.h>

#define

WRITER 2

//

写者数量

.
2

#define

READER 4

//

读者数量

4

#define

BUFFER_SIZE 8

//

缓冲区

(

大小
为

8
)

int

writeOffset = 0;

//

写者写内容的位置

int

readOffset = 0;

//

读者取内容的位置

int

buffer[BUFFER_SIZE] = {

'#'

};

// '#'

字符代表空间没有内容

sem_t

empty_sem;

//

同步信号量，
当满了时阻止写者写

.

sem_t

full_sem;

//

同步信号量，
当没有内容时阻止读者读

pthread_mutex_t

mutexlock;

//

互斥锁，
一次只有一个线程访问缓冲

char

letters[52] =
{

"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

};

/*

*

打印缓冲情况

*/

void

printBuffer

()
{

int

i;

printf

(

"/t

当前缓冲区内容

:/t"

);

for

(i = 0; i < BUFFER_SIZE; i++)

printf

(

"%c
"

,
buffer[i]);

printf

(

"/n"

);

}

void

writer

(

int

*id) {

srand

((

unsigned

)
time(NULL));

int

index = 0;

while

(1) {

sleep

(1);

//

先等待

//sem_wait(

&empty_sem

);//

等待缓冲区可写信号

.

pthread_mutex_lock

(&mutexlock);

//

下面的条件语句为

if

时一位读写者

,

一次读写一个字母

.

改为

while

时则不同

.

if

(buffer[writeOffset
% BUFFER_SIZE] ==

'#'

)
{

//

如果有空间可写

index
=

rand

()
% 52;

writeOffset
= writeOffset % BUFFER_SIZE;

buffer[writeOffset]
= letters[index];

printf

(

"

第

%2d

位写者写了一个字母

%c
/n"

,
*id,buffer[writeOffset]);

printBuffer();

++writeOffset;

}

//WHILE

//

传递出

,

已经生产满的信号

.

然后解锁

//sem_post(

&full_sem

);

pthread_mutex_unlock

(&mutexlock);

}

}

void

reader

(

int

*id) {

while

(1) {

sleep

(1);

//sem_wait(

&full_sem

);//

等待写者写好的信号

pthread_mutex_lock

(&mutexlock);

//

if

(buffer[readOffset
% BUFFER_SIZE] !=

'#'

)
{

//

有东西
可读

printf

(

"

第

%2d

位读者读出了一个字母

%c
/n"

,
*id,buffer[readOffset]);

readOffset
= readOffset % BUFFER_SIZE;

buffer[readOffset]
=

'#'

;

++readOffset;

}

//sem_post(

&empty_sem

);

pthread_mutex_unlock

(&mutexlock);

}

}

int

main

()
{

pthread_t

writePID[WRITER];

//2

pthread_t

readerPID[READER];

//4

int

ret;

//

ret

~ return value

int

i;

//for
loop

int

wID[WRITER];

//

读者与写者的编号

,

因为线程的标识符太长了

,

不好看

.

int

rID[READER];

/**

*

初始化同步信号量

*/

ret
=

sem_init

(&empty_sem,
0, BUFFER_SIZE);

if

(ret != 0) {

perror

(

"

sem

init

failed /n"

);

exit

(EXIT_FAILURE);

}

ret
=

sem_init

(&full_sem,
0, BUFFER_SIZE);

if

(ret != 0) {

perror

(

"

sem

init

failed /n"

);

exit

(EXIT_FAILURE);

}

/**

*

初始化互斥信号量

*/

ret
=

pthread_mutex_init

(&mutexlock,NULL);

if

(ret != 0) {

perror

(

"

mutexlock

init

failed /n"

);

exit

(EXIT_FAILURE);

}

/***

*

初始缓冲区的内容

*/

for

(i
= 0; i < BUFFER_SIZE;i++){

buffer[i]
=

'#'

;

}

printBuffer();

//

打印开始时候缓冲区的内容

:

/**

*

创建

WRITER(2)

个写者线程

*/

for

(i = 0; i < WRITER; i++) {

wID[i]
= i+1;

ret
=

pthread_create

(&writePID[i],
NULL, (

void

*) *writer, &wID[i]);

if

(ret != 0) {

perror

(

"writer
create failed /n"

);

exit

(EXIT_FAILURE);

}

}

/**

*

创建

READER(4)

个消费者线程

*/

for

(i = 0; i < READER; i++) {

rID[i]
= i+1;

ret
=

pthread_create

(&readerPID[i],
NULL, (

void

*) *reader, &rID[i]);

if

(ret != 0) {

perror

(

"reader
create failed /n"

);

exit

(EXIT_FAILURE);

}

}

/**

*

等待线程完成

.

*/

for

(i = 0; i < WRITER; i++) {

pthread_join

(writePID[i],
NULL);

}

for

(i = 0; i < READER; i++) {

pthread_join

(readerPID[i],
NULL);

}

exit

(EXIT_SUCCESS);

}

/***

*

编译运行命令

:

*

banxi

@

banxi

:~/

jeework

/

pthread

$

gcc

-g -o

rwer

ReaderWriter.c -

lpthread

*

*

下面是运行结果及分析

:

总共有五不同次测试结果及分析

.

*
banxi1@

banxi

:~/

jeework

/

pthread

$
./

rwer

当前缓冲区内容

: #
# # # # # # #

第

1

位写者写了一个字母

F

当前缓冲区内容

: F
# # # # # # #

第

1

位读者读出了一个字母

F

第

2

位写者写了一个字母

n

当前缓冲区内容

: #
n # # # # # #

第

2

位读者读出了一个字母

n

第

1

位写者写了一个字母

C

当前缓冲区内容

: #
# C # # # # #

第

3

位读者读出了一个字母

C

第

2

位写者写了一个字母

X

当前缓冲区内容

: #
# # X # # # #

第

4

位读者读出了一个字母

X

第

1

位写者写了一个字母

c

当前缓冲区内容

: #
# # # c # # #

^C

banxi1988@banxi1988-desktop:~/

jeework

/

pthread

$

(

说明

:

因为程序没有自己终止

,

所以用

CTRL+C

来中断

.)

ret

= sem_init(

&full_sem

,
0, 0);

由于上面对于

full_sem

的初始值为

0,

终止值也是为

0,

所以出现

,

了读出一个写一个的状态

,

而不是写满之后再读完

.

一个读者一次读写一次的话

,

也是程序为了容易观察结果而设定的

.

因为判断是

if.

如果改成

while

就会不同了

.

将在下面对其进行测试

.

但把上面的改为如下的

:

ret

= sem_init(

&full_sem

,0,BUFFER_SIZE);

时程序运行结果如下

:

banxi1988@banxi1988-desktop:~/

jeework

/

pthread

$
./

rwer

当前缓冲区内容

: #
# # # # # # #

第

1

写者写了一个字母

p

当前缓冲区内容

: p
# # # # # # #

第

1

位读者读出了一个字母

p

第

2

写者写了一个字母

X

当前缓冲区内容

: #
X # # # # # #

第

2

位读者读出了一个字母

X

第

1

写者写了一个字母

t

当前缓冲区内容

: #
# t # # # # #

第

2

写者写了一个字母

t

当前缓冲区内容

: #
# t t # # # #

第

4

位读者读出了一个字母

t

第

3

位读者读出了一个字母

t

第

1

写者写了一个字母

M

当前缓冲区内容

: #
# # # M # # #

第

2

写者写了一个字母

J

当前缓冲区内容

: #
# # # M J # #

第

2

位读者读出了一个字母

M

第

3

位读者读出了一个字母

J

第

1

写者写了一个字母

Y

当前缓冲区内容

: #
# # # # # Y #

第

2

写者写了一个字母

m

测试结果三

:

将上面的条件设置

while

时的结果

:

banxi1988@banxi1988-desktop:~/

jeework

/

pthread

$
./

rwer

当前缓冲区内容

: #
# # # # # # #

第

2

位写者写了一个字母

p

当前缓冲区内容

: p
# # # # # # #

第

2

位写者写了一个字母

W

当前缓冲区内容

: p
W # # # # # #

第

2

位写者写了一个字母

r

当前缓冲区内容

: p
W r # # # # #

第

2

位写者写了一个字母

e

当前缓冲区内容

: p
W r e # # # #

第

2

位写者写了一个字母

d

当前缓冲区内容

: p
W r e d # # #

第

2

位写者写了一个字母

Z

当前缓冲区内容

: p
W r e d Z # #

第

2

位写者写了一个字母

G

当前缓冲区内容

: p
W r e d Z G #

第

2

位写者写了一个字母

s

当前缓冲区内容

: p
W r e d Z G s

第

4

位读者读出了一个字母

p

第

4

位读者读出了一个字母

W

第

4

位读者读出了一个字母

r

第

4

位读者读出了一个字母

e

第

4

位读者读出了一个字母

d

第

4

位读者读出了一个字母

Z

第

4

位读者读出了一个字母

G

第

4

位读者读出了一个字母

s

第

1

位写者写了一个字母

e

当前缓冲区内容

: e
# # # # # # #

第

1

位写者写了一个字母

F

当前缓冲区内容

: e
F # # # # # #

第

1

位写者写了一个字母

E

当前缓冲区内容

: e
F E # # # # #

第

1

位写者写了一个字母

N

当前缓冲区内容

: e
F E N # # # #

第

1

位写者写了一个字母

I

当前缓冲区内容

: e
F E N I # # #

第

1

位写者写了一个字母

A

当前缓冲区内容

: e
F E N I A # #

第

1

位写者写了一个字母

Y

当前缓冲区内容

: e
F E N I A Y #

第

1

位写者写了一个字母

U

当前缓冲区内容

: e
F E N I A Y U

^C

banxi1988@banxi1988-desktop:~/

jeework

/

pthread

$

运行结果四

:

去掉了待等待
相应信号量的代码

..

这样的话读写的控制就又

if

或者

while

来判断了

.

这个一来

,sleep

就必不可少

,

因为只有在一个线程

sleep

和时候

,

其它的线程才有抢占线程的平均的机会

.

为什么说平均呢

,

因为当写满或者读完的时候

,

线程也会释放掉锁的

.

但是马上又加入了抢点锁的过程

.

banxi1988@banxi1988-desktop:~/

jeework

/

pthread

$
./

sigwrer

当前缓冲区内容

: #
# # # # # # #

第

1

位写者写了一个字母

s

当前缓冲区内容

: s
# # # # # # #

第

2

位读者读出了一个字母

s

第

2

位写者写了一个字母

h

当前缓冲区内容

: #
h # # # # # #

第

1

位读者读出了一个字母

h

第

1

位写者写了一个字母

Y

当前缓冲区内容

: #
# Y # # # # #

第

2

位读者读出了一个字母

Y

第

2

位写者写了一个字母

I

当前缓冲区内容

: #
# # I # # # #

第

1

位读者读出了一个字母

I

第

1

位写者写了一个字母

D

当前缓冲区内容

: #
# # # D # # #

第

2

位读者读出了一个字母

D

第

2

位写者写了一个字母

Q

当前缓冲区内容

: #
# # # # Q # #

第

3

位读者读出了一个字母

Q

第

1

位写者写了一个字母

c

当前缓冲区内容

: #
# # # # # c #

第

2

位写者写了一个字母

z

^C

banxi1988@banxi1988-desktop:~/

jeework

/

pthread

$

运行结果五

:

这个是将线程的信号量全都注释掉之后的代码

.

发现

,

读写纯种不再是交互执行的了

.

不过还是存在某些规律的

,

比如

,

先写的然后读的

.

这个也许是调度问题吧

..

banxi1988@banxi1988-desktop:~/

jeework

/

pthread

$

gcc

-g -o

sigwrer

ReaderWriter.c -

lpthread

banxi1988@banxi1988-desktop:~/

jeework

/

pthread

$
./

sigwrer

当前缓冲区内容

: #
# # # # # # #

第

2

位写者写了一个字母

M

当前缓冲区内容

: M
# # # # # # #

第

1

位写者写了一个字母

m

当前缓冲区内容

: M
m # # # # # #

第

1

位读者读出了一个字母

M

第

2

位读者读出了一个字母

m

第

2

位写者写了一个字母

v

当前缓冲区内容

: #
# v # # # # #

第

1

位写者写了一个字母

p

当前缓冲区内容

: #
# v p # # # #

第

2

位读者读出了一个字母

v

第

1

位读者读出了一个字母

p

第

2

位写者写了一个字母

O

当前缓冲区内容

: #
# # # O # # #

第

1

位写者写了一个字母

A

当前缓冲区内容

: #
# # # O A # #

第

2

位读者读出了一个字母

O

第

1

位读者读出了一个字母

A

第

2

位写者写了一个字母

y

当前缓冲区内容

: #
# # # # # y #

^C

banxi1988@banxi1988-desktop:~/

jeework

/

pthread

$

*

*/