[megoldva] Python Thread queue hogyan

Sziasztok!

A kovetkezo problemam van: Komunikacio szalak kozott queue-val. Valami ilyesmit probalok megvalositani (a kod sokkal hosszabb es osszetettebb, szoval megprobaltam, csak az idevonatkoz reszt reprodukalni itt):


class CsvManage():
    CsvReadNames(gettnameline):
       # give back a list

class A.(threading.Thread):
   def __ini__(self, csvget, csvput)
      self.csvget = csvget
      self.csvput = csvput
   def run(self)
      csvdata = CsvManage()
      while 1:
          try:
              gettnameline = self.csvnameget.get(True, 0.05)
              self.csvnameput.put(csvdata.CsvReadNames(gettnameline))
          except Queue.Empty:
              continue

class B.(threading.Thread):
   def __ini__(self, searcheddir, csvnameget, csvnameput)
      self.searcheddir = searcheddir
      self.csvnameget = csvnameget
      self.csvnameput = csvput
   def run(self):
      while 1
         self.csvnameget.put(self.searcheddir)
         csvfilenames = self.csvnameput.get()
         print 'OK'


threadLock = threading.Lock()
threads = []

csvnameget = Queue.Queue()
csvnameput = Queue.Queue()
csvworking = A(csvnameget, csvnameput)
csvworking.start()
threads.append(csvworking)

TEF = B.(searcheddir, csvnameget, csvnameput)
TEF.start()
threads.append(TEF)

for t in threads:
    t.join()
print "Exiting Main Thread"


Szoval : TEF a searcheddir str-et berakja a csvnameget queue-ba, ahonan a csvworking A class threat kiveszi es lefutatja a csvdata ahonan visszakap egy list-et. Ez eddig mukodik. A csvdata.CsvReadNames(gettnameline) a list amit vissza akarok adni a TEF-nek, szoval berakom a csvnameput queue-ba. De ez valami miatt nem mukodik. Mindenfele hibauzenet nelkul TEF nem lep tovabb a print 'OK'-ra. Valalmi otlet mi lehet az oka?

Ez az elso eset amikor Python Threat-kel dolgozok, szoval ha lehet ne hulyezetek le egybol.

Hozzászólások

A kód megnézése nélkül: GIL-ről tudsz?

Megegyszer koszonom az infot.
A problema elso korben nem kapcsolodik a GIL-hez, viszont amikor atolvastam nehany cikket rola, rengeteg ujat tanultam.

Van valalmi ami szoget utot a fejembe: a GIL miatt CPython eseten lenyegeben a max sebbeseg = 1 szal. Ahogy no a szallak szama ugy csokken a teljesitmeny. Szoval 1-n kapcsolat eseten a szalak kozott az 1 oldali szalat erdemese C++ atirni?

Mondtam, hogy valószínűleg nem kapcsolódik hozzá, viszont jó tudni.
(off: szálak: egy darab 'l'. sebesség: egy darab 'b').

Ezt a max. sebesség=1 szál dolgot nem értem. Az, hogy mennyi szál fut adott pillanatban, az nem sebesség. És miért lenne jobb az 1 oldali szál C-be átírása?

Még egy off:
Egy kicsit árnyalnám egyébként a dolgot, mert például ha C nyelven írsz saját modult, akkor el tudod engedni a GIL-t.

De lehet, hogy egyszerűbb lenne neked a multiprocessing modult használni.

Amikor olvastam a temaban ezt talaltam:

Each thread that wants to run must wait for the GIL to be released by the other thread, which means your multi-threaded Python application is essentially single threaded, right? Yes. Not exactly. Sort of.

A lenyeg, hogy ha nem vegzel magas IO muveleteket, akkor a max sebbeseg = 1 thread sebbeseg. Ez nagyabol az en esetem. Az n oldali szalak csak szamolast vegeznek, mig az 1 oldal vegzi az IO muveleteket.

Szoval a hiba igazabol a tervezes fogyatekosagaira mutat ra:
van ugye tobb B szal, ami egyetlen A szalal komonikalt. Ami fontos a B szalak nem felcserelhetok, szoval a B1-nem tudja hasznalni a B2-nek szant adatokat, szoval amikor B1 kivette a queue-bol a B2-nek szant adatokat, akkor B2 egy vegtelen ciklusban kerulve varta a neki szant adatokat. A problemat ugy eleg egyszeru megoldani: a B1 visszarakja a queue-ba a nem neki szant adatokat.
Itt jon a DE: viszont ez ramutat arra, hogy a szallak rengeteg idot toltenek azzal, hogy a varjak a nekik szant adatokat.

Szoval ha jol ertelmezem a queue nem igazan idealis a n-1 tipusu kapcsolatra szalak kozott. Jol latom?

Ha igen milyen szinkronizalas javasolnatok?