Introducir

Domine los principios de comunicación entre procesos basados en colas de mensajes y memoria compartida

Proyecto experimental

Comunicación entre procesos basada en la cola de mensajes y memoria compartida

Propósito experimental

1. Profundizar en la comprensión del concepto de proceso, aclarar la diferencia entre proceso y programa, comprender mejor la esencia de la ejecución concurrente.
2. Gestión de procesos maestros y comunicación de procesos.
3. El mecanismo de comunicación de proceso (IPC) del sistema Linux permite intercambiar grandes cantidades de datos entre procesos arbitrarios.
4. El propósito de este experimento es comprender y familiarizarse con:
5. Mecanismo de comunicación de mensajes compatible con Linux y su método de uso
6. Principio y método de uso del área de almacenamiento compartido del sistema Linux.

Vista previa experimental

1. Message Queue Server
1. Descripción general de Message Queue Server:
Message Queue Server es una lista vinculada de mensajes, almacenados en la memoria y mantenidos por el núcleo.
2. Las características de la
cola de mensajes : la cola de mensajes permite que uno o más procesos escriban o lean mensajes, y cada mensaje tiene un tipo, la
cola de mensajes puede implementar una consulta aleatoria de mensajes, y los mensajes no tienen que ser primero en entrar, primero en salir. Lectura secuencial, puede leer según el tipo de mensaje al programar; al
igual que la canalización sin nombre y la canalización famosa, lea el mensaje de la cola de mensajes, los datos en la cola de mensajes se eliminarán.
El mensaje en la cola de mensajes también está formateado;
el mensaje solo se eliminará cuando el núcleo se reinicie o se elimine manualmente. Si la cola de mensajes no se elimina manualmente, la cola de mensajes siempre existirá en la memoria; el
identificador de la cola de mensajes identifica el mensaje Cola La cola de mensajes está completa;
es única en el sistema.
En segundo lugar, la memoria compartida La memoria
compartida permite que dos o más procesos compartan un área de almacenamiento determinada.
La memoria compartida es la forma más rápida de compartir datos entre procesos. Un proceso escribe datos en un área de memoria compartida, y todos los procesos que comparten esta área de memoria pueden ver inmediatamente el contenido.
El uso de memoria compartida debe prestar atención a la exclusión mutua de acceso a un área de almacenamiento dada entre múltiples procesos. Si un proceso está escribiendo datos en el área de memoria compartida, ningún otro proceso debe leer o escribir los datos antes de completar este paso.

Contenido experimental

Primero,
cree una cola de mensajes, envíe y reciba mensajes Cree una cola de mensajes, llame a msgget (), msgsnd (), msggrev (), msgctrl () y otras funciones para enviar y recibir mensajes entre los dos procesos.
Segundo, la creación, conexión y desconexión del almacenamiento compartido
Cree memoria compartida, use shmget (), shmat (), shmctl (), shmctl () y otras funciones para lograr la comunicación entre los dos procesos.

Equipo experimental

Windows PC
Linux Ubuntu

Instrucciones de diseño de principios básicos

Primero, el principio de diseño:
para facilitar la operación y los resultados de observación, un programa se usa como una "introducción", y dos procesos secundarios, servidor y cliente, se crean a través de la función fork () para comunicarse.
Segundo, la cola de mensajes: el
servidor establece una cola de mensajes con una clave de 75, esperando los mensajes enviados por otros procesos. Cuando se encuentra un mensaje de tipo 1, sirve como señal de finalización, cancela la cola y sale del servidor. El servidor muestra una oración "(El servidor) recibió el tipo de fecha (n) es:" después de recibir un mensaje; El
cliente usa una cola de mensajes con una clave de 75 para enviar mensajes de tipo 10 a 1 sucesivamente, y luego sale. El último mensaje es la señal de finalización requerida por el servidor. Cada vez que el Cliente envía un mensaje, muestra "(El cliente) el tipo de fecha de envío (n) es:"; el
proceso principal finaliza después de que el servidor y el cliente salen.
3. Memoria compartida: el
servidor establece una cola de mensajes con una clave de 75, esperando los mensajes enviados por otros procesos. Cada vez que el servidor recibe un mensaje, muestra un "(Servidor) recibido"; El
cliente utiliza una cola de mensajes con una clave de 75 para recibir mensajes en la memoria compartida. Cada vez que el Cliente envía un mensaje, muestra un "(Cliente) enviado"; el
proceso padre finaliza después de que el servidor y el cliente salen.

Procedimiento experimental

Primero, la cola de mensajes

1. Escriba un programa y utilice la llamada fork del sistema () para crear dos servidores secundarios y un cliente. El proceso primario espera a que finalicen los dos procesos secundarios y luego se cierra.

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
int main(int argc ,char *argv[])
{

	pid_t pid;
	pid = fork();	
	if(pid <0)
	{
		printf("fork error\n");
	}
	if(pid ==0)
	{			
	}
	else
	{		
		pid_t pid;
		pid = fork();
		if(pid <0)
		{
			printf("fork error\n");
		}
		if(pid ==0)
		{	    
		}
		}else{
			wait(NULL);
			sleep(1);
			printf("Main process quit\n");	
		}	
	}	
	return 0;
}

2. Cree la estructura de formato de mensaje de la cola de mensajes.

typedef struct _msg
{
	long msgtype;
	char m[500];

}MSG;

3. En el lado del cliente, cree una cola de mensajes con un valor clave de 75 y envíe la cadena con el valor inicial de "abcdefghij" 10 veces en un bucle. Después de cada envío, el puntero se desplaza un bit para lograr un efecto diferente para cada contenido enviado. Al mismo tiempo, el tipo de mensaje de cada mensaje enviado se reduce de 10 a 1. Cuando se envía el mensaje con el tipo de mensaje 1, el lado del cliente sale.

if(pid ==0)
	{
		int msgqid;
		int i = 0;
		msgqid = msgget(75,IPC_CREAT|0666);
		MSG msg;
		memset(msg.m,0,sizeof(msg.m));
		msg.msgtype = 10;
		char *a = "abcdefghij";
		for(;i < 11;i++)
		{
			strcpy(msg.m,a);
			sleep(1);
			msgsnd(msgqid,&msg,sizeof(msg.m),0);		
			printf("(Client)sent datetype %ld: %s\n",msg.msgtype,msg.m);
			msg.msgtype--;
			a++;
			if(msg.msgtype == 0 )
			{
				sleep(1);
				printf("Client sent over and shutdown now\n");
				exit(0);
			}
		}		
	}

4. En el lado del servidor, cree una cola de mensajes con un valor clave de 75 y reciba mensajes de la cola de mensajes en tiempo real. El tipo de mensaje recibido se reduce de 10 a 1. Después de recibir el mensaje con el tipo de mensaje 1, la cola de mensajes se destruye. Salir

if(pid ==0)
		{
	    int msgqid;
		int type = 10;
		msgqid = msgget(75,IPC_CREAT|0666);
		MSG msg;
		while(1)
		{
			msgrcv(msgqid,&msg,sizeof(msg.m),type,0);	
			printf("\t\t\t\t\t(Server)receiveddatetype %d: %s\n",type,msg.m);
			type--;
			if(type == 0)
			{
				msgctl(msgqid,IPC_RMID,NULL);
				sleep(1);
				printf("Sever get type 1 date and shutdown \n");
				sleep(1);
				printf("message queue destroyed\n");
				sleep(2);
				exit(0);
			}
		}

5. El efecto de ejecución es el siguiente:
Inserte la descripción de la imagen aquí

Segundo, memoria compartida

Escriba un programa, utilice la llamada fork del sistema () para crear dos procesos secundarios servidor y cliente, el proceso primario espera a que finalicen y salgan los dos procesos secundarios.

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/shm.h>
#include <sys/ipc.h>
#include <fcntl.h>
#include <string.h>
#define BUF 2048
int main(int argc,char *argv[])
{
	pid_t pid;
	pid = fork();
	if(pid < 0)
	{
		perror("fork error\n");
	}
	if(pid == 0)
	{	
		
	}
	else{
	    pid_t pid;
		pid = fork();
		if(pid < 0)
		{
			perror("fork error\n");
         	}
		if(pid == 0)
		{
		
		}
		else{	
			wait(NULL);
			sleep(2);
			printf("Process quit\n");
		    }	
	    }
	return 0;
}

En el lado del cliente, cree una memoria compartida con un valor de clave de 75 y un tamaño de 2048 que pueda leerse y escribirse.Después de que se asigna la memoria compartida, la cadena con el valor inicial de "5201314" se envía 10 veces en un bucle y el puntero se envía cada vez. Retroceda un bit para lograr un efecto diferente cada vez que se envíe el contenido. Hasta que se envíe el mensaje con el contenido de "4", el cliente finaliza naturalmente.

if(pid == 0)
	{	
		int shmid;
		int i = 0;
		char *a = "5201314";
		shmid = shmget(75,BUF,SHM_R|SHM_W|IPC_CREAT);
		char *shmadd;
		shmadd = shmat(shmid,NULL,0);
		bzero(shmadd,BUF);
		for(;i < 7;i++){
			sleep(1);
			bzero(shmadd,BUF);
			strcpy(shmadd,a);
			printf("(Client) sent: %s\n",shmadd);
			a++;
		     }
	}

3. En el lado del servidor y del lado del cliente, cree una memoria compartida con un valor clave de 75 y un tamaño de 2048 que pueda leerse y escribirse. Después de que la memoria compartida está asignada, el mensaje enviado por el cliente en la memoria compartida se recibe en tiempo real y cuando se completa la recepción Después del mensaje con el contenido de "4", desasigne la memoria compartida, destruya la memoria compartida y finalice el proceso.

if(pid == 0)
		{
		int shmid;
		shmid = shmget(75,BUF,SHM_R|SHM_W|IPC_CREAT);
		char *shmadd;
		shmadd = shmat(shmid,NULL,0);
		bzero(shmadd,BUF);
		while(1){
				sleep(1);
				printf("\t\t\t\t(Server) received: %s\n",shmadd);
				if(*shmadd == '4')
				{
					exit(0);
				}
			}
		shmdt(shmadd);
		shmctl(shmid,IPC_RMID,NULL);
		}

4. El efecto de ejecución es el siguiente:
Inserte la descripción de la imagen aquí

Experiencia de análisis

Análisis: siempre y cuando domine los principios de creación y control de procesos, creación de colas de mensajes y llamadas a funciones relacionadas, creación de memoria compartida y llamadas a funciones relacionadas, puede completarlas paso a paso de acuerdo con sus respectivos principios de comunicación .
Experiencia: a través de la operación práctica de este experimento, me di cuenta de que el diseño de aplicaciones de Linux es de hecho un curso altamente operable. La operación práctica es verificar y dominar el conocimiento teórico de los libros de texto, fortalecer mi comprensión de Ubuntu y ser más competente en ello. La mejor manera de realizar operaciones es experimentar los principios operativos relacionados con las colas de mensajes y la memoria compartida a través de operaciones personales, y ganar mucho, lo que sienta una base sólida para el aprendizaje futuro.

Resultados experimentales

Con el éxito de los resultados de la prueba, la creación y el control del proceso, la creación de la cola de mensajes y la comunicación entre procesos, y la creación de la memoria compartida en la comunicación entre procesos se han ejecutado con éxito.