duda de threads

Sab Jun 4 11:02:18 CEST 2005

Nos vendria bien saber si son thread/hebras/hilos o procesos.
Si son procesos, que por lo que dice de saber el pid tiene pinta, te dejo aqui 
un programita chorra que puede darte ideas.

-------------- inicio codigo -----------------------

import os
import time
import signal
import sys

childpid = -1

def seHaMuertoUnHijo(sig,frame):
  global childpid

  pid, status = os.wait()
  print "PARENT: PID=%d, se ha muerto el hijo %s" % (
    os.getpid(),
    pid
  )
  if childpid == pid:
    childpid = -1

def main():
  global childpid

  signal.signal(signal.SIGCHLD,seHaMuertoUnHijo)
  ppid=os.getpid()
  print "PARENT: PID=%d" % os.getpid()
  childpid = os.fork()
  if childpid == 0:
    while True:
      print "CHILD : PID=%d, PPID=%d" % (
        os.getpid(),
        os.getppid()
      )
      time.sleep(1)
    sys.exit(0)
  for n in range(5):
    print "PARENT: PID=%d" % os.getpid()
    time.sleep(2)
  if childpid > 0:
    os.kill(childpid,signal.SIGTERM)
    print "PARENT: he hecho el kill."
  print "PARENT: Haz un ps y comprueba que se ha muerto el hijo."
  time.sleep(20)
  print "PARENT: Ahora me muero yo."

main()

-------------- fin codigo -----------------------
(El codigo de arriba va en un python 2.4+FreeBSD 5.4)

El programa no hace nada, pero puede servir de primera guia sobre como se 
pueden lanzar y matar procesos. Hay que tener algunas cosas importantes en 
mente:

- fork() solo va en sistemas "Unix like" no en güindous.
- fork(), en el padre retorna el pid del hijo y en el hijo cero.
- Hay un pollo con las señales (me suena que ya se trato en la lista hace un 
tiempo).

Las señales.
Cuando un proceso hijo se muere envia una señal SIGCHLD al padre. Si en padre 
no trata esta señal, el proceso hijo se queda "zombie". Lo que hacemos es 
atrapar la señal SIGCHLD y hacer un wait, con lo que conseguimos asegurarnos 
de que el proceso hijo se muere sanamente y no se quede zombie.

No estaria mal leer:
- Ayuda del modulo "os" respecto a fork y wait.
- Ayuda del modulo signal.
- man 2 fork
- man 2 wait 

No estaria mal montar algo mas estructurado como una clase que se encargase de 
lanzar y controlar que hijos estan vivos y cuales no. Podria ser algo como :

-------------- inicio codigo -----------------------

class ChildHandler(object):

  def __init__(self):
    self._childs = list()
    signal.signal(signal.SIGCHLD,self.__notifyHandler)

  def __notifyHandler(self,sig,frame):
    # Esperamos que el hijo se muera sanamente y recogemos su pid y status.
    pid, status = os.wait()
    if pid in self._childs:
      # Si estaba en la lista de hijos lo quitamos, por que ya se ha muerto.
      self._child.remove(pid)

  def start(self, function, *args, **kw):
    # Recive la funcion y argumentes que tiene que ejecutar en el proceso
    # los ejecuta y guarda el pid del hijo.
    childpid = os.fork()
    if childpid == 0:
      # En el proceso hijo ejecutamos la funcion pasada.
      n=function(*args, **kw)
      # Ahora nos preocupamos que el hijo retorne como status el valore 
      # re retorno de la funcion.
      try:
        n=int(n)
      except:
        n=0
      sys.exit(n)
    # una vez lanzado el proceso hijo metemos su pid en la lista.
    self._childs.append(childpid)
    return chilpid

  def kill(self, childpid):
    if childpid in self._childs:
      # Si no esta en la lista es que ya se habra muerto.
      os.kill(childpid,signal.SIGTERM)

-------------- fin codigo -----------------------
(Este codigo no lo he ejecutado, solo es una idea)

Ademas me parece que con python 2.4 habian añadido algo para manejo de 
subprocesos (modulo subprocess) que se supone multiplataforma (osea, que 
funciona en Güindous), pero aun no lo he mirado.

Bueno, creo que ya es bastante por ahora, si  sirbe, aqui esta.
Si hay dudas preguntar, que si se sabe y puede, se contestar.

Un saludo
Joaquin.

El Viernes, 3 de Junio de 2005 17:22, Pepe Aracil escribió:
> El Viernes, 3 de Junio de 2005 11:12, Julio Canto escribió:
> > pepe wrote:
> > >Hola
> > >Estoy  haciendo una cola de trabajos en red, ya he conseguido lanzar mas
> > > o menos los trabajos. El servidor  será  "el padre" y los "hijos" seran
> > > los trabajos lanzados. Mi duda es que pasos he de seguir para antes de
> > > lanzarlos a ejecutar saber el pid del hijo(trabajo lanzado)  para poder
> > > hacer un kill. Otra duda que tengo es komo puedo saber si aun se esta
> > > ejecutando un trabajo para ver si he de liberarlo y ponerlo como un
> > > nodo libre.
> >
> > Los 'threads' no los puedes matar. Lo que puedes hacer es meterles algun
> > mecanismo interno para comunicarles que 'se mueran' ellos solos (p.e.
> > una propiedad que tu puedas modificar desde fuera del objeto, y que
> > dicho objeto consulte durante el desarrollo de su actividad para saber
> > si debe continuar). Un thread es un objeto, y puedes llamar al metodo
> > 'isAlive' para saber si esta muerto o no.
> >
> > Un saludo,
> >     JC
> > _______________________________________________
> > Python-es mailing list
> > Python-es en aditel.org
> > http://listas.aditel.org/listinfo/python-es
>
> Me parece que se refiere a procesos no a hebras.
>
> No lo he mirado, pero seguro que hay un sistema para lanzar procesos hijos
> y obtener su PID para despues poder "matarlo" o saber si ha muerto solito
> para reemplazarlo por otro proceso de la cola.
>
> Por cierto, yo no soy  el Pepe del post original.
> _______________________________________________
> Python-es mailing list
> Python-es en aditel.org
> http://listas.aditel.org/listinfo/python-es

______________________________________________ 
Renovamos el Correo Yahoo! 
Nuevos servicios, más seguridad 
http://correo.yahoo.es