进程与线程——Linux进程与线程通讯…

最新推荐文章于 2023-08-23 19:53:58 发布

极客剑

最新推荐文章于 2023-08-23 19:53:58 发布

阅读量1.9k

点赞数 1

分类专栏：操作系统实验

本文链接：https://blog.csdn.net/L_Jsword/article/details/15811715

版权

操作系统实验专栏收录该内容

7 篇文章 3 订阅

订阅专栏

实验一进程与线程——Linux进程与线程通讯

一、实验目的

深刻理解线程和进程的概念，掌握线程与进程在组成成分上的差别，以及与其相适应的通讯方式和应用目标。

二、实验内容

1、以Linux系统进程和线程机制为背景，掌握fork()和clone()系统调用的形式和功能，以及与其相适应的高级通讯方式。由fork派生的子进程之间通过pipe通讯，由clone创建的线程之间通过共享内存通讯，对于后者需要考虑互斥问题。

2、以生产者/消费者问题为例，通过实验理解fork()和clone()两个系统调用的区别。程序要求能够创建4个进程或线程，其中包括两个生产者和两个消费者，生产者和消费者之间能够传递数据。

三、实验设计

1、用pipe()创建一个管道文件，然后用fork()创建两个生产进程和两个消费进程，它们之间通过pipe()传递信息。

程序代码：

#include"sched.h"

#include"pthread.h"

#include"stdio.h"

#include"stdlib.h"

#include"string.h"

#include"semaphore.h"

#define CLONE_VM 0x00000100

#define CLONE_FS 0x00000200

#define CLONE_FILES 0x00000400

#define CLONE_SIGHAND 0x00000800

int producer(void *args);

int consumer(void *args);

pthread_mutex_t mutex;

sem_t product;

sem_t warehouse;

char buffer[8][4];

int bp=0;

int main(int argc,char**argv)

{

pthread_mutex_init(&mutex,NULL);

sem_init(&product,0,0);

sem_init(&warehouse,0,8);

int clone_flag,*arg, args[2] = {0, 1},retval;

char *stack;

clone_flag= CLONE_VM|CLONE_SIGHAND|CLONE_FS|CLONE_FILES;

int i;

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

{

arg = &args[i] ;

stack=(char*)malloc(4096);

retval = clone((void*)producer,&(stack[4095]),clone_flag,(void*)arg);

stack=(char*)malloc(4096);

retval = clone((void*)consumer,&(stack[4095]),clone_flag,(void*)arg);

}

exit(1);

}

int producer(void *args)

{

int id=*((int*)args);

int i;

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

{

sleep(i+1);

sem_wait(&warehouse);//P operate

pthread_mutex_lock(&mutex);

if(id==0)

strcpy(buffer[bp],"aaa\0");//producer 1 write

else

strcpy(buffer[bp],"bbb\0");//producer 2 write

bp++;

printf("producer %d produce %s in %d\n",id, buffer[bp-1],bp-1);

pthread_mutex_unlock(&mutex);

sem_post(&product);//V operate

}

printf("producer %d is over!\n",id);

}

int consumer(void *args)

{

int id=*((int*)args);

int i;

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

{

sleep(10-i);

sem_wait(&product);//P operate

pthread_mutex_lock(&mutex);

bp--;

printf("consumer %d get %s in %d\n",id,buffer[bp],bp);

strcpy(buffer[bp],"zzz\0");

pthread_mutex_unlock(&mutex);

sem_post(&warehouse);

}

printf("consumer %d is over!\n",id);

}

运行结果

dbwi@dbwi-virtual-machine:~$ gcc experiment2.c -o exper2 -lpthread

dbwi@dbwi-virtual-machine:~$ ./exper2

dbwi@dbwi-virtual-machine:~$ producer 1 produce bbb in 0

producer 0 produce aaa in 1

producer 1 produce bbb in 2

producer 0 produce aaa in 3

producer 1 produce bbb in 4

producer 0 produce aaa in 5

consumer 1 get aaa in 5

consumer 0 get bbb in 4

producer 1 produce bbb in 4

producer 0 produce aaa in 5

producer 1 produce bbb in 6

producer 0 produce aaa in 7

consumer 1 get aaa in 7

consumer 0 get bbb in 6

producer 1 produce bbb in 6

producer 0 produce aaa in 7

consumer 1 get aaa in 7

consumer 0 get bbb in 6

producer 1 produce bbb in 6

producer 0 produce aaa in 7

consumer 1 get aaa in 7

consumer 0 get bbb in 6

producer 1 produce bbb in 6

producer 0 produce aaa in 7

consumer 1 get aaa in 7

consumer 0 get bbb in 6

consumer 0 get aaa in 5

consumer 1 get bbb in 4

producer 0 produce aaa in 4

producer 1 produce bbb in 5

consumer 0 get bbb in 5

consumer 1 get aaa in 4

consumer 1 get aaa in 3

consumer 0 get bbb in 2

consumer 0 get aaa in 1

consumer 1 get bbb in 0

producer 0 produce aaa in 0

producer 0 is over!

consumer 1 get aaa in 0

consumer 1 is over!

producer 1 produce bbb in 0

producer 1 is over!

consumer 0 get bbb in 0

consumer 0 is over!

2、用clone()创建四个轻进程（线程），用参数指明共享内存等资源，通过共享内存模拟生产消费问题，利用pthread_mutex_lock(), pthread_mutex_unlock()等函数实现对共享存储区访问的互斥。

程序代码：

#include"sys/types.h"

#include"sys/file.h"

#include"unistd.h"

#include"stdio.h"

#include"stdlib.h"

#include"string.h"

char r_buf[4];//

char w_buf[4];

int pipe_fd[2];

pid_t pid1,pid2,pid3,pid4;

int producer(int id);

int consumer(int id);

int main(int argc,char**argv)

{

if(pipe(pipe_fd)<0)

{

printf("pipe create error.\n");

exit(-1);

}

else

{

printf("pipe is created successfully!\n");

if((pid1=fork())==0)

producer(1);

if((pid2=fork())==0)

producer(2);

if((pid3=fork())==0)

consumer(1);

if((pid4=fork())==0)

consumer(2);

}

close(pipe_fd[0]);

close(pipe_fd[1]);

int i,pid,status;

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

pid=wait(&status);

exit(0);

}

int producer(int id)

{

printf("producer %d is running!\n",id);

close(pipe_fd[0]);// first , close the read of consumer

int i=0;

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

{

sleep(3);

if(id==1)

{

strcpy(w_buf,"AAA\0");//producer 1 write

printf("producer %d write %s to the w_buf\n",id,w_buf);

}

else

{

strcpy(w_buf,"BBB\0");//producer 2 write

printf("producer %d write %s to the w_buf\n",id,w_buf);

}

if(write(pipe_fd[1],w_buf,4)==-1)

printf("write to pipe error\n");

}

close(pipe_fd[1]);

printf("producer %d is over!\n",id);

exit(id);

}

int consumer(int id)

{

close(pipe_fd[1]);//first , close writing of producer

printf("consumer %d is running!\n",id);

if(id==1)

strcpy(w_buf,"CCC\0"); //

else

strcpy(w_buf,"DDD\0");

while(1)

{

sleep(1);

strcpy(r_buf,"EEE\0");

if(read(pipe_fd[0],r_buf,4)==0)

break;

printf("consumer %d get %s,while the w_buf is %s\n",id,r_buf,w_buf);

}

close(pipe_fd[0]);

printf("consumer %d is over!\n",id);

exit(id);

}

运行结果

dbwi@dbwi-virtual-machine:~$ gcc experiment1.c -o exper1

dbwi@dbwi-virtual-machine:~$ ./exper1

pipe is created successfully!

consumer 2 is running!

consumer 1 is running!

producer 1 is running!

producer 2 is running!

producer 2 write BBB to the w_buf

consumer 2 get BBB,while the w_buf is DDD