[SOLUCIONADO] Problema con hilos

[pabloryser]

Hola a todos. Estoy comenzando con Python, haciendo un curso, en el que nos han dado un problema.
Mi problema es que no termino de entender hilos y lo poco que encuentro dando vueltas está en inglés.
Tengo la idea de como hacer funcionar el programa. mi problema es la implementación de hilos "Threads".
Queria ver si podian darme una mano. Les muestro lo que tengo.
Entre las lineas 57 y 60 estaria mi problema, el buffer.
Y en la consulta de vuelos "lector" tenia pensado hacer 2 listas: Una para reservas, con los 1000 asientos con booleanos y otra solo con los asientos reservados. Que no lo hice todavia, me importa mas el buffer.
Agradecería mucho ayuda

Código Python:

# Simular con hilos un sistema de reservación de vuelos. Las personas pueden consultar y reservar vuelos.
# Hacer la sincronización con múltiples personas accediendo al registro de vuelos.
# Cuando se reserva no se puede consultar y viceversa. Lanzar 20 hilos
# 1000 lugares en el avion.
 
import threading
import random
import time
 
class Reserva(threading.Thread):
    
    def __init__(self, nombreHilo, asientos, condicion, cant):
 
        threading.Thread.__init__(self, name = nombreHilo)
        self.cant=cant
        self.condicion=condicion
        self.asientos=asientos
        
    def run(self):
        #Reserva
        
        for i in range(self.cant):
            self.condicion.acquire()
            time.sleep(random.randrange(5))
            a=random.randint(1,1000)-1
            self.asientos[a]=False
            
            print ("Se reservó el asiento "+ str(a))
        
        self.condicion.notify()
        self.condicion.release()
        time.sleep(random.randrange(2))
 
class Consulta(threading.Thread):
    
    def __init__(self, nombreHilo, asientos, condicion, cant):
 
        threading.Thread.__init__(self, name = nombreHilo)
        self.cant=cant
        self.condicion=condicion
        self.asientos=asientos
                
    def run(self):
        self.condicion.acquire()
        
        asientos2=self.asientos
        print("prueba")
        
        list.count(x)  #asientos disponibles
                
        time.sleep(random.randrange(2))
        self.condicion.wait()
        self.condicion.release()
 
condicion = threading.Condition()
asi_vuelo = []
for v in range(1000):           #Armando el avion
    asi_vuelo.append(True)
 
#vuelo = BufferCircular()               #Aca está mi problema
lector = Consulta("Consulta", asi_vuelo, condicion, 20)
escritor = Reserva("Reserva", asi_vuelo, condicion, 20)
 
lector.start()
escritor.start()
 
lector.join()
escritor.join()
 

[pabloryser]

Lo hice... CASI!!!
Está separado en clases y funcionando mas o menos.
Hice el avión mas chico para verificar datos repetidos que deberían obviarse con un while en la linea 18 de la clase reserva.
El tema es que Reserva el asiento 15 por ejemplo y en la lista de ocupados me guarda un 16, y a partir de ahi todos los numeros tienen una pequeña variación, no se cual podría ser el problema (Clase vuelo linea 13).

Ayuda por favor, he plantado culo en asiento y avancé bastante, pero parece que "ALGO" no estoy viendo bien.

Desde ya muchas gracias.

Edito: Ya di con el error. En la linea 13 de la clase Vuelo paso a la nueva lista el orden del valor y no el valor en si y difieren en primera instancia en 1 (aumenta a medida q voy sacando). Todavia tengo que resolverlo.

Código Python(main):

# Simular con hilos un sistema de reservación de vuelos. Las personas pueden consultar y reservar vuelos.
# Hacer la sincronización con múltiples personas accediendo al registro de vuelos.
# Cuando se reserva no se puede consultar y viceversa. Lanzar 20 hilos
# 1000 lugares en el avion.
 
from Buffer import Vuelo                     #Buffer, Ev_lector y Ev_escritor son los modulos
from Ev_lector import Consulta
from Ev_escritor import Reserva
 
vuelo = Vuelo()             
lector = Consulta("Consulta", vuelo, 20)
escritor = Reserva("Reserva", vuelo, 20)
 
lector.start()
escritor.start()
 
lector.join()
escritor.join()
 

Código Python(Clase Reserva):

import threading
import random
import time
 
class Reserva(threading.Thread):
    
    def __init__(self, nombreHilo, asientos, cant):
 
        threading.Thread.__init__(self, name=nombreHilo)
        self.cant=cant
        self.asientos=asientos
        
    def run(self):
        #Reserva
        for i in range(self.cant):
            time.sleep(random.randrange(3))
            a=random.randint(1,100)
            while (self.asientos.vuelo.count(a)==0):
                a=random.randint(1,100)
            self.asientos.set(a)
            print ("El hilo "+str(self.name)+" reserva el asiento "+ str(a))
 

Código Python(Clase Consulta):

import threading
import random
import time
 
class Consulta(threading.Thread):
    
    def __init__(self, nombreHilo, asientos, cant):
 
        threading.Thread.__init__(self, name = nombreHilo)
        self.cant=cant
        self.asientos=asientos
                
    def run(self):
                
        for i in range(self.cant):
            time.sleep(random.randrange(3))
            #a=self.asientos.ocup
            
            print("La lista de asientos ocupados es la siguiente: \n" + str(self.asientos.get())+"\n")
 

Código Python(Clase Vuelo):

import threading
 
class Vuelo:
 
    def __init__(self):
        self.vuelo = []
        for v in range(1,101):
            self.vuelo.append(v)
        print(str(self.vuelo))
        self.ocup=[]
                    
    def set(self,asiento):
        self.ocup.append(self.vuelo.pop(asiento))
        
    def get(self):
        asi_oc=self.ocup
        return asi_oc
 

[pabloryser]

Ahora si, funcionando.
No se si estará bien implementado el tema de los hilos, pero funciona bien.
Se los dejo por si a alguien le sirve.
Si alguien tiene algo mas para aportar bienvenido sea!!
Gracias por leer esto jeje.

Código Python:

# Simular con hilos un sistema de reservación de vuelos. Las personas pueden consultar y reservar vuelos.
# Hacer la sincronización con múltiples personas accediendo al registro de vuelos.
# Cuando se reserva no se puede consultar y viceversa. Lanzar 20 hilos
# 1000 lugares en el avion.
 
from Buffer import Vuelo                    #<-- Buffer, Ev_lector y Ev_escritor son los nombres de los modulos
from Ev_lector import Consulta
from Ev_escritor import Reserva
 
cant_asi=1000
cant_consultas=20
cant_reservas=20
vuelo = Vuelo(cant_asi)             
lector = Consulta("Consulta", vuelo, cant_consultas)
escritor = Reserva("Reserva", vuelo, cant_reservas)
 
lector.start()
escritor.start()
 
lector.join()
escritor.join()
 
asi_oc=vuelo.get()
print("Lista final de asienos reservados:\n{0}".format(str(asi_oc)))
 

Código Python:

import threading
 
class Vuelo:
 
    def __init__(self, cant):
        self.vuelo = []
        self.cant=cant
        for v in range(1,self.cant+1):
            self.vuelo.append(v)
        #print(str(self.vuelo)) <--- Era para verificar el armado de la lista de asientos
        self.ocup=[]
                    
    def set(self,asiento):
        self.ocup.append(asiento)
        self.vuelo.remove(asiento)
    def get(self):
        asi_oc=self.ocup
        asi_oc.sort()
        return asi_oc
    def get_cant(self):
        par=self.cant
        return par
 

Código Python:

import threading
import random
import time
 
class Reserva(threading.Thread):
    
    def __init__(self, nombreHilo, asientos, cant):
 
        threading.Thread.__init__(self, name=nombreHilo)
        self.cant=cant
        self.asientos=asientos
        
    def run(self):
        #Reserva
        for i in range(self.cant):
            time.sleep(random.randrange(5))
            a=random.randint(1,self.asientos.get_cant())
            while (self.asientos.vuelo.count(a)==0):
                a=random.randint(1,self.asientos.get_cant())
            self.asientos.set(a)
            print ("El hilo "+str(self.name)+" reserva el asiento "+ str(a))
 

Código Python:

import threading
import random
import time
 
class Consulta(threading.Thread):
    
    def __init__(self, nombreHilo, asientos, cant):
 
        threading.Thread.__init__(self, name = nombreHilo)
        self.cant=cant
        self.asientos=asientos
                
    def run(self):
                
        for i in range(self.cant):
            time.sleep(random.randrange(5))
            asi_oc=self.asientos.get()
            print("El hilo {1} consulta la lista de asientos ocupados y es la siguiente: \n {0} \n".format(str(asi_oc), str(self.name)))
 

[nup_]

Desgraciadamente no es tan sencillo.
"vuelo" es un recurso compartido por 2 hilos, por tanto debes sincronizar su acceso.
Lee un poco acerca de sincronización de hilos en python:
http://mundogeek.net/archivos/2008/0...ads-en-python/

Un poco de teoría no te vendría mal tampoco:
http://es.wikipedia.org/wiki/Sem%C3%...maci%C3%B3n%29

Nup_

[pabloryser]

Si, estaba al tanto de que no estaba sincronizado (pero andaba). Me falta el "adquire". Pero lo hice con la contras de que 1- entendia poco 2-material que encontraba estaba en ingles 3-problema de versiones cuando encontraba algo .
Voy a ver eso que me pusiste, muchas gracias.

[pabloryser]

AHORA SI RESUELTO, SINCRONIZADO Y FUNCIONANDO (por si sirve de ayuda a alguien)

Código Python:

#Este es el main
 
# Simular con hilos un sistema de reservación de vuelos. Las personas pueden consultar y reservar vuelos.
# Hacer la sincronización con múltiples personas accediendo al registro de vuelos.
# Cuando se reserva no se puede consultar y viceversa. Lanzar 20 hilos
# 1000 lugares en el avion.
 
from Buffer import Vuelo
from Ev_lector import Consulta
from Ev_escritor import Reserva
 
cant_asi=20
cant_consultas=5
cant_reservas=5
vuelo = Vuelo(cant_asi)             
lector = Consulta("Consulta", vuelo, cant_consultas)
escritor = Reserva("Reserva", vuelo, cant_reservas)
 
lector.start()
escritor.start()
 
lector.join()
escritor.join()
 
asi_oc=vuelo.get("MAIN")
print("Lista final de asienos reservados:\n{0}".format(str(asi_oc)))
 

Código Python:

# "Ev_lector"
 
import threading
import random
import time
 
class Consulta(threading.Thread):
    
    def __init__(self, nombreHilo, asientos, cant):
 
        threading.Thread.__init__(self, name = nombreHilo)
        self.cant=cant
        self.asientos=asientos
                
    def run(self):
                
        for i in range(self.cant):
            #time.sleep(random.randrange(5))
            asi_oc=self.asientos.get(self.name)
            print("El hilo {1} consulta la lista de asientos ocupados y es la siguiente: \n {0} \n".format(str(asi_oc), str(self.name)))
 

Código Python:

# "Ev_escritor"
 
import threading
import random
import time
 
class Reserva(threading.Thread):
    
    def __init__(self, nombreHilo, asientos, cant):
 
        threading.Thread.__init__(self, name=nombreHilo)
        self.cant=cant
        self.asientos=asientos
        
    def run(self):
        #Reserva
        for i in range(self.cant):
            #time.sleep(random.randrange(5))
            a=random.randint(1,self.asientos.get_cant())
            while (self.asientos.vuelo.count(a)==0):
                a=random.randint(1,self.asientos.get_cant())
            self.asientos.set(a, self.name)
            print ("El hilo "+str(self.name)+" reserva el asiento "+ str(a))
 

Código Python:

# "Buffer"
 
import threading
import time
import random
 
class Vuelo:
 
    def __init__(self, cant):
        self.vuelo = []
        self.cant=cant
        for v in range(1,self.cant+1):
            self.vuelo.append(v)
        #print(str(self.vuelo)) <--- Era para verificar el armado de la lista de asientos
        self.ocup=[]
        self.candado = threading.Lock()
                    
    def set(self, asiento, nombre):
        self.candado.acquire()
        print("-*"*25)
        print("Toma control "+nombre)            #Para verificar que no se pise el hilo
        time.sleep(random.randrange(5))
        self.ocup.append(asiento)
        self.vuelo.remove(asiento)
        print("Suelta control "+nombre)
        self.candado.release()
        
    def get(self, nombre):
        self.candado.acquire()
        print("-"*50)
        print("Toma control "+nombre)            #Para verificar que no se pise el hilo
        asi_oc=self.ocup
        asi_oc.sort()
        print("Suelta control "+nombre)
        self.candado.release()
        return asi_oc
        
    def get_cant(self):
        par=self.cant
        return par