实验二进程同步实验

实验二进程同步

一、实验目的：

掌握基本的同步算法，理解经典进程同步问题的本质；学习使用Linux的进程同步机制，掌握相关API的使用方法；能利用信号量机制，采用多种同步算法实现不会发生死锁的哲学家进餐程序。

二、实验平台：

虚拟机：VMWare9以上

操作系统：Ubuntu12.04以上

编辑器：Gedit | Vim

编译器：Gcc

三、实验内容：

（1）以哲学家进餐模型为依据，在Linux控制台环境下创建5个进程，用semget函数创建一个信号量集（5个信号量，初值为1），模拟哲学家的思考和进餐行为：每一位哲学家饥饿时，先拿起左手筷子，再拿起右手筷子；筷子是临界资源，为每一支筷子定义1个互斥信号量；想拿到筷子需要先对信号量做P操作，使用完释放筷子对信号量做V操作。

伪代码描述：

semaphore chopstick[5]={1,1,1,1,1};

?第i位哲学家的活动可描述为：

do{

printf("%d is thinking\n",i);

printf("%d is hungry\n",i);

wait(chopstick［i］); //拿左筷子

wait(chopstick［(i+1) % 5］); //拿右筷子

printf("%d is eating\n",i);

signal(chopstick［i］); //放左筷子

signal(chopstick［(i+1) % 5］); //放右筷子

…

}while[true];

运行该组进程，观察进程是否能一直运行下去，若停滞则发生了什么现象？并分析原因。（2）解决哲学家进餐问题可采用如下方法：a.仅当哲学家的左、右两只筷子均可用时，才允许他拿起筷子进餐；b.至多只允许有4位哲学家同时去拿左边的筷子，最终能保证至少有一位哲学家能够进餐；c.规定奇数号哲学家先拿起他左手的筷子，然后再拿起他右手的筷子，而偶数号哲学家则先拿起他右手的筷子，然后再拿起他左手的筷子。方法a在示例程序中给出，请用方法b和c写出不会发生死锁的哲学家进餐程序。

（3）设计程序，实现生产者/消费者进程(线程)的同步与互斥。在该程序中创建4个进程（或线程）模拟生产者和消费者，实现进程(线程)的同步与互斥。

A方法：

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#ifdef _SEM_SEMUN_UNDEFINED

union semun

{

int val;

struct semid_ds *buf;

unsigned short *array;

struct seminfo *__buf;

};

#endif

#define ERR_EXIT(m) \

do { \

perror(m); \

exit(EXIT_FAILURE); \

} while(0)

int wait_1chopstick(int no,int semid)

{

struct sembuf sb = {no,-1,0};

int ret;

ret = semop(semid,&sb,1);

if(ret < 0) {

ERR_EXIT("semop");

}

return ret;

}

int free_1chopstick(int no,int semid)

{

struct sembuf sb = {no,1,0};

int ret;

ret = semop(semid,&sb,1);

if(ret < 0) {

ERR_EXIT("semop");

}

return ret;

}

#define DELAY (rand() % 5 + 1)

void wait_for_2chopstick(int no,int semid) {

int left = no;

int right = (no + 1) % 5;

struct sembuf buf[2] = {

{left,-1,0},

{right,-1,0}

};

semop(semid,buf,2);

}

void free_2chopstick(int no,int semid) {

int left = no;

int right = (no + 1) % 5;

struct sembuf buf[2] = {

{left,1,0},

{right,1,0}

};

semop(semid,buf,2);

}

void philosophere(int no,int semid)

{

srand(getpid());

for(;;) {

printf("%d is thinking\n",no);

sleep(DELAY);

printf("%d is hungry\n",no);

wait_for_2chopstick(no,semid);

printf("%d is eating\n",no);

sleep(DELAY);

free_2chopstick(no,semid);

#else

int left = no;

int right = (no + 1) % 5;

printf("%d is thinking\n",no);

sleep(DELAY);

printf("%d is hungry\n",no);

wait_1chopstick(left,semid);

sleep(DELAY);

wait_1chopstick(right,semid);

printf("%d is eating\n",no);

sleep(DELAY);

free_1chopstick(left,semid);

free_1chopstick(right,semid);

#endif

}

}

int main(int argc,char *argv[])

{

int semid;

semid = semget(IPC_PRIVATE,5,IPC_CREAT | 0666);

if(semid < 0) {

ERR_EXIT("semid");

}

union semun su;

su.val = 1;

int i;

for(i = 0;i < 5;++i) {

semctl(semid,i,SETVAL,su);

}

int num = 0;

pid_t pid;

for(i = 1;i < 5;++i) {

pid = fork();

if(pid < 0) {

ERR_EXIT("fork");

if(0 == pid) {

num = i;

break;

}

}

philosophere(num,semid);

return 0;

}

B方法：

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

union semun

{

int val;

struct semid_ds *buf; unsigned short *array;

struct seminfo *_buf;

};

#define ERR_EXIT(m) \

do { \

perror(m); \

exit(EXIT_FAILURE); \

} while(0)

//获取互斥信号量

void wait_mutex(int mutex)

{

struct sembuf sb={0,-1,0};

semop(mutex,&sb,1);//对互斥信号量进行操作}

//取得筷子

void wait_v(int semid,int num)

{

struct sembuf sb={num,-1,0};

semop(semid,&sb,1);

}

//释放筷子

void signal_p(int semid,int num)

{

struct sembuf sb={num,1,0};

semop(semid,&sb,1);

}

//释放互斥变量mutex

void signal_mutex(int semid0)

{

struct sembuf sb={0,1,0};

semop(semid0,&sb,1);

}

//ph函数

void ph(int num,int semid,int semid0)

{

int left=num;

int right=(num+1)%5;

for(;;)

{

printf("%d is thinking\n",num);

sleep(1);

printf("%d is hungry\n",num);

sleep(1);

//wait操作，控制哲学家最多4人能进餐wait_mutex(semid0);

wait_v(semid,left);

wait_v(semid,right);

printf("%d is eating\n",num);

sleep(1);

//signal操作

signal_p(semid,right);//释放右筷子

signal_p(semid,left);//释放左快子

signal_mutex(semid0);//释放互斥信号量

}

}

//主函数

int main(int argc,char *argv[])

{

int semid,semid0;

//创建两个信号量集

semid0=semget(IPC_PRIV A TE,1,IPC_CREAT | 0666);

semid=semget(IPC_PRIV A TE,5,IPC_CREAT | 0666);

//

union semun su;

su.val=1;

int i;

for(i=0;i<5;i++)

{

//semctl()系统调用在一个信号量集(或集合中的单个信号量)上执行各种控制操作semctl(semid,i,SETV AL,su);

}

//设定semid0信号量的初始值

union semun su0;

su0.val=4;

semctl(semid0,0,SETV AL,su0);

//创建4个子进程

int num=0;

pid_t pid;

for(i=1;i<5;i++)

{

pid=fork();

if(pid<0) {ERR_EXIT("fork");}

if(pid==0) {num=i;break;}

}

//第num个哲学家要做的事

ph(num,semid,semid0);

return 0;

}

C方法：#include #include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

union semun

{

int val;

struct semid_ds *buf; unsigned short *array;

struct seminfo *__buf;

};

#define ERR_EXIT(m) \

do { \

perror(m); \

exit(EXIT_FAILURE); \

} while(0)

//取得筷子

void wait_v(int semid,int num) {

struct sembuf sb={num,-1,0}; semop(num,&sb,1);

//释放筷子

void signal_p(int semid,int num)

{

struct sembuf sb={num,-1,0};

semop(num,&sb,1);

}

//科学家要做的事

void ph(int semid,int num)

{

for(;;)//死循环

{

//判断哲学家的编号是奇数还是偶数

//奇数先申请左边的筷子，偶数先申请右边的筷子if(num%2!=0)

{//判断奇数

printf("%d is thinking\n",num);

sleep(1);

printf("%d is hungry\n",num);

sleep(1);

//wait操作

wait_v(semid,num);

wait_v(semid,(num+1)%5);

printf("%d is eating\n",num);

sleep(1);

//signal操作

signal_p(semid,(num+1)%5);

signal_p(semid,num);

}

if(num%2==0)

{//判断偶数

printf("%d is thinking\n",num);

sleep(1);

printf("%d is hungry\n",num);

sleep(1);

//wait操作

wait_v(semid,(num+1)%5);

wait_v(semid,num);

//signal操作

signal_p(semid,num);

signal_p(semid,(num+1)%5);

}

}

int main(int argc,char *argv[])

{

int semid;

//创建5个信号量

semid=semget(IPC_PRIV A TE,5,IPC_CREAT | 0666); union semun su;

su.val=1;

int i;

for(i=0;i<5;i++)

{

//注意第二个参数也是索引

semctl(semid,i,SETV AL,su);

}

//创建4个子进程

pid_t pid;

int num=5;

for(i=0;i<4;i++)

{

pid=fork();

if(pid<0) { ERR_EXIT("fork");}

if(pid==0) { num=i;break;}

}

//哲学家要做的事

ph(semid,num);

return 0;

}

生产者和消费者的同步与互斥：

#include

#include

#include

#include

#include

#define N 2 // 消费者或者生产者的数目

#define M 10 // 缓冲数目

int in = 0; // 生产者放置产品的位置

int out = 0; // 消费者取产品的位置

int buff[M] = {0}; // 缓冲初始化为0，开始时没有产品

sem_t empty_sem; // 同步信号量，当满了时阻止生产者放产品sem_t full_sem; // 同步信号量，当没产品时阻止消费者消费pthread_mutex_t mutex; // 互斥信号量，一次只有一个线程访问缓冲int product_id = 0; //生产者id

int prochase_id = 0; //消费者id

/* 打印缓冲情况*/

void print()

{

int i;

for(i = 0; i < M; i++)

printf("%d ", buff[i]);

printf("\n");

}

/* 生产者方法*/

void *product()

{

int id = ++product_id;

while(1)

{

// 用sleep的数量可以调节生产和消费的速度，便于观察

sleep(1);

//sleep(1);

sem_wait(&empty_sem);

pthread_mutex_lock(&mutex);

in = in % M;

printf("product%d in %d. like: \t", id, in);

buff[in] = 1;

print();

++in;

pthread_mutex_unlock(&mutex);

sem_post(&full_sem);

}

}

/* 消费者方法*/

void *prochase()

{

int id = ++prochase_id;

while(1)

{

// 用sleep的数量可以调节生产和消费的速度，便于观察

sleep(1);

//sleep(1);

sem_wait(&full_sem);

pthread_mutex_lock(&mutex);

out = out % M;

printf("prochase%d in %d. like: \t", id, out);

buff[out] = 0;

print();

++out;

pthread_mutex_unlock(&mutex);

sem_post(&empty_sem);

}

}

int main()

{

pthread_t id1[N];

pthread_t id2[N];

int i;

int ret[N];

// 初始化同步信号量

int ini1 = sem_init(&empty_sem, 0, M);

int ini2 = sem_init(&full_sem, 0, 0);

if(ini1 && ini2 != 0)

{

printf("sem init failed \n");

exit(1);

}

//初始化互斥信号量

int ini3 = pthread_mutex_init(&mutex, NULL);

if(ini3 != 0)

{

printf("mutex init failed \n");

exit(1);

}

// 创建N个生产者线程

for(i = 0; i < N; i++)

{

ret[i] = pthread_create(&id1[i], NULL, product, (void *)(&i));

if(ret[i] != 0)

{

printf("product%d creation failed \n", i);

exit(1);

}

}

//创建N个消费者线程

for(i = 0; i < N; i++)

{

ret[i] = pthread_create(&id2[i], NULL, prochase, NULL);

if(ret[i] != 0)

{

printf("prochase%d creation failed \n", i);

exit(1);

}

}

//销毁线程

for(i = 0; i < N; i++)

{

pthread_join(id1[i],NULL);

pthread_join(id2[i],NULL);

}

exit(0);

}

四.实验心得

通过本次试验我掌握了基本的同步算法，理解了经典进程同步问题的本质；学习了使用Linux的进程同步机制，掌握了相关API的使用方法；能利用信号量机制，采用多种同步算

法实现不会发生死锁的哲学家进餐程序。