[Python-es] clases singleton, herededas de thread, que se instancian a su vez desde otros hilos...

[Jose Caballero]

Hola,

tengo que implementar un código algo complicado (para mi nivel), y necesito
de la ayuda de la lista.
He buscado bastante en google sobre clases Singleton, y me he encontrado con
el problema de que he obtenido demasiada información, y mucha de ella
contradictoria.
Intentaré explicar el problema. Para simplicarlo,

1.  voy a necesitar crear 3 clases (a las que llamaré C1, C2 y C3), la
primera  de ellas "abstracta" de la que se heredaran N clases hijas (a las
que llamaré H1, ... Hn)

2. Tanto las N clases hijas como la clase C2 deben ser 'Singleton'.

3. Todas las clases a su vez serán 'threads'. Es decir, todas ellas
heredarán de threading.Thread

4. Los objectos de las clases H1...Hn y C2 se instanciarán desde los objetos
de la clase C3.


Vendría a ser algo como lo siguiente (quitando todo el código no relevante):

------------------------------------------------------------------------------------------------------------------


class C1(threading.Thread):
        """esta clase debe ser singleton,
        o bien sus clases hijas deben serlo.
        """
        # bla bla

class H1(C1):
        """esta clase debe ser singleton, de alguna forma
        """
        # bla bla
...
class Hn(C1):
        """esta clase debe ser singleton
        """
        # bla bla

------------------------------------------------------------------------------------------------------------------

class C2(threading.Thread):
        """esta clase debe ser singleton, de alguna forma
        """
        def __init__  .... bla bla
        def run(self) .... bla bla
        # bla bla

------------------------------------------------------------------------------------------------------------------

class C3(threading.Thread):
        def __init__ ... bla bla
        def run(self):
                obj_H1 = H1()
                obj_H1.start()
                ...
                obj_Hn = Hn()
                obj_Hn.start()

                obj_C2 = C2()
                obj_C2.start()
                # bla bla
        # bla bla

obj_C3_1 = C3()
obj_C3_1.start()
...
obj_C3_j = C3()
obj_C3_j.start()

------------------------------------------------------------------------------------------------------------------


Aquí me surgen varias dudas, que esperon me ayuden a despejar.

A. ¿Es necesario que C1 sea 'singleton', o solo deberían serlo H1...Hn? ¿O
da igual?

B. ¿Es mejor que C1 herede de threading.Threading o sería mejor que lo hagan
H1...Hn? ¿O da igual?

C. El hecho de que los objetos de C2 y de H1...Hn se instancien desde
objetos que son a su vez hilos, ¿puede hacer que las clases C2 y H1...Hn
dejen de ser realmente 'singletons'?
¿Hay alguna forma de implementar los 'singleton' para que sean resistentes
al hecho de que sus objetos se instanciarán desde hilos?

D. ¿Cuál es la forma más sencilla de implementar los 'singleton' en python?
He visto mil y una soluciones en google, lo que me hace pensar que no existe
una forma verdadera. Me conformo con la más sencilla... ;)




Muchas gracias por adelantado por toda la ayuda que me puedan dar.
Saludos,
Jose
------------ próxima parte ------------
Se ha borrado un adjunto en formato HTML...
URL: <http://mail.python.org/pipermail/python-es/attachments/20110531/f88133be/attachment.html>