2018-10-03.md

Programación multiproceso:

• Ejecutables. Procesos. Servicios.
• Estados de un proceso.
• Hilos.
• Programación concurrente.
• Programación paralela y distribuida.
• Comunicación entre procesos.
• Gestión de procesos.
• Sincronización entre procesos.
• Programación de aplicaciones multiproceso.

Conceptos:

• Multiproceso
• BCP
• Process status
• Estados de un proceso
• System
• Funciones
• Función main
• Creación y ejecución de procesos
• Padre crear hijo
• Comunicación entre procesos
• Descriptores
• Ficheros
• Pipes
  • Sin nombre
    • https://www.jesusninoc.com/2018/08/03/c-programming-in-linux-tutorial-037-pipe-function/
  • Con nombre
    • https://github.com/mememiguelo/PSP/blob/master/C/Otros/Fifo.c
    • https://github.com/mememiguelo/PSP/blob/master/C/Otros/fifocrea.c
    • https://github.com/mememiguelo/PSP/blob/master/C/Otros/fifoescribe.c
• Sincronizar procesos
• Señales
• Creación procesos Java
• Programación concurrente
• Condiciones de Bernstein
• Programación paralela
• Memorias compartidas
• Semáforos
• Programación distribuida

Descriptores

Valor	entero	Nombre
0	Entrada estándar	stdin
1	Salida estándar	stdout
2	Error estándar	stderr

Pipes

Sin nombre

Cuando el flujo de información va del hijo hacia el padre:

• El padre debe cerrar el descriptor de escritura fd[1].
• El hijo debe cerrar el descriptor de lectura fd[0].

El proceso hijo envía al proceso padre mediante el uso de pipes el mensaje "Hola papi"

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

void main(){

     int fd[2];
     char buffer[30];
     pid_t pid;

     //#include<unistd.h>
     // int pipe(int fd[2]);
     // fd[0] contiene el descriptor para lectura

     pipe(fd); // Se crea el PIPE
     pid = fork();

     switch(pid){
     
          case -1: // Error
                printf("No se ha podido crear un hijo \n");
                exit(-1);
                break;
          case 0: // Hijo
                close(fd[0]); // Cierra el descriptor que no va a usar. El de lectura
                printf("El hijo escribe en el PIPE... \n");
                write(fd[1], "Hola papi", 10);
                break;
          default: // Padre
                close(fd[1]); // Cierra el descriptor de escritura
                wait(NULL); // Espera a que finalice el hijo
                printf("El padre lee el PIPE \n");
                read(fd[0], buffer, 10);
                printf("\t Mensaje leido: %s \n", buffer);
     }
}

Cuando el flujo de información va del padre hacia el hijo:

• El padre debe cerrar el descriptor de lectura fd[0].
• El hijo debe cerrar el descriptor de escritura fd[1].

El proceso padre envía al proceso hijo mediante el uso de pipes el mensaje "Buenos dias hijo"

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include<string.h>

int main(void)
{
	int fd[2];
	pid_t pid;

	char saludoPadre []="\n MENSAJE=> Buenos dias hijo.";
	char buffer[80];

	pipe(fd); //creo pipe

	pid =fork(); //creo proceso

	switch(pid)
	{
		case -1 : //ERROR
			printf("NO SE HA PODIDO CREAR HIJO ... ");
			exit(-1);
		case 0://HIJO RECIBE
			close(fd[1]);//cierra el descriptor de escritura
			read(fd[0],buffer,sizeof(buffer)); //leo el pipe 
			printf("El HIJO recibe algo del pipe: %s\n",buffer);
			break;
		default ://PADRE ENVIA
			close(fd[0]);
			write(fd[1], saludoPadre,strlen(saludoPadre));//escribo en pipe
			printf("El PADRE ENVIA MENSAJE AL HIJO ...\n");
			wait(NULL); //espero al proceso hijo
			break;
	}

	return 0;
}

• https://github.com/mememiguelo/PSP/blob/master/C/Otros/comunicacionPadreHijo.c
• https://github.com/mememiguelo/PSP/blob/master/C/Otros/comunicacionPadreHijo2.c
• https://www.jesusninoc.com/2018/08/03/c-programming-in-linux-tutorial-037-pipe-function/

Con nombre

mknod

http://man7.org/linux/man-pages/man2/mknod.2.html

mknod (Bash)

mknod FIFO p
l -l FIFO
cat FIFO
l > FIFO

mknod (C)

#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>

mknod("FIFO1",S_IFIFO|0660,0);

• https://github.com/mememiguelo/PSP/blob/master/C/Otros/fifocrea.c
• https://github.com/mememiguelo/PSP/blob/master/C/Otros/fifoescribe.c

Señales

Teoría

Chapter 12. Catching signals

https://linux.die.net/Bash-Beginners-Guide/sect_12_01.html

signal

http://man7.org/linux/man-pages/man2/signal.2.html

kill

http://man7.org/linux/man-pages/man2/kill.2.html

pause

http://man7.org/linux/man-pages/man2/pause.2.html

Ejercicios sobre señales

Enviar dos señales SIGUSR1 a un proceso hijo desde el padre

https://github.com/mememiguelo/PSP/blob/master/C/Otros/sincronizar-1.c

Enviar señales entre un proceso padre y otro hijo que se ejecutan de forma síncrona

https://github.com/mememiguelo/PSP/blob/master/C/Otros/sincronizar.c