Ver Mensaje Individual
  #9 (permalink)  
Antiguo 22/12/2009, 06:42
GagleKas
 
Fecha de Ingreso: abril-2008
Mensajes: 141
Antigüedad: 16 años, 1 mes
Puntos: 0
De acuerdo Respuesta: signal: SIGALRM

El siguiente codigo es solo un ejemplo para ver que si que se puede usar la misma interrupcion con diferentes procesos, porque al hacer el fork se crea una copia identica (menos el pid), por lo que las variables globales e interrupciones no generan problemas.

No he hecho 2 contadores con un unico SIGALRM porque para ver el resultado por pantalla tendria que modificar ciertas cosas que podrian causar confusion con el objetivo del programa.


Código C:
Ver original
  1. #include <signal.h>
  2. #include <stdio.h>
  3.  
  4. int n = 0;
  5.  
  6. void intSIGUSR1 (){
  7.         printf ("%d\n", n);
  8. }
  9.  
  10. int main (){
  11.         int pidHijo1, pidHijo2;
  12.  
  13.         pidHijo1 = fork ();
  14.  
  15.         if (pidHijo1 == 0){
  16.                 //Hijo
  17.                 signal (SIGUSR1, intSIGUSR1);
  18.                 n = 1;
  19.                 kill (getpid (), SIGUSR1);
  20.  
  21.                 exit (0);
  22.         }else if (pidHijo1 < 0){
  23.                 //Error
  24.                 exit (-1);
  25.         }
  26.  
  27.         pidHijo2 = fork ();
  28.  
  29.         if (pidHijo2 == 0){
  30.                 //Hijo
  31.                 signal (SIGUSR1, intSIGUSR1);
  32.                 n = 2;
  33.                 kill (getpid (), SIGUSR1);
  34.  
  35.                 exit (0);
  36.         }else if (pidHijo2 > 0){
  37.                 //Padre
  38.                 waitpid (pidHijo1, NULL, 0);
  39.                 waitpid (pidHijo2, NULL, 0);
  40.         }else{
  41.                 //Error
  42.                 exit (-1);
  43.         }
  44.  
  45.         return 0;
  46. }

Este programa solo muestra 1 y 2 por pantalla, o 2 y 1, si el scheduler asi lo decide.

En lugar de la variable global n, ahi pondria la variable del socket.

Primero haria el accept (). Una vez llega un cliente esta funcion me devuelve el fd del socket. Este fd lo copio en la variable global y genero un hijo para atender al cliente. Listo, el hijo tendra el fd del socket en la variable global con el que se comunicara con el cliente y a la vez se podra usar para enviar timeouts.

Si llegan mas conexiones de clientes pues no pasa nada. De la misma forma se guarda en la variable global el fd del socket creado con accept () y se crea el hijo, el cual tendra en esta variable global el fd del socket con el que se comunicara con el cliente.

Puede que al principio se piense que se esta usando memoria compartida (la variable global) entre proceso padre e hijo, pero no es asi. El siguiente codigo lo deja mas claro:

Código C:
Ver original
  1. #include <stdio.h>
  2.  
  3. int main (){
  4.         int x = 0, pidHijo;
  5.  
  6.         pidHijo = fork ();
  7.  
  8.         if (pidHijo == 0){
  9.                 //Hijo
  10.                 printf ("Hijo: %d\n", x); //muestra 0 por pantalla
  11.                 exit (0);
  12.         }else if (pidHijo > 0){
  13.                 //Padre
  14.                 x = 1;
  15.                 printf ("Padre: %d\n", x); //muestra 1 por pantalla
  16.                 waitpid (pidHijo, NULL, 0);
  17.         }else{
  18.                 //Error
  19.                 return -1;
  20.         }
  21.  
  22.         return 0;
  23. }

Ahora en lugar de la x pon la variable global. La idea es la misma.




Bueno, espero que quien tenga el mismo problema que yo y use el google, le salga este post. xDDD


Saludos.

Última edición por GagleKas; 22/12/2009 a las 06:58