[Python] Alternatief voor Queue in Multiprocessing

[FireDrunk]

Om mijn programming skills eens te poetsen ben ik met Python begonnen.
Ik ben bezig met een klein multiprocessing scriptje wat data van een commandline applicatie presenteert via een miniscule webserver. (onder FreeBSD)

Nu heb ik al een goede tutorial gevonden om multiprocessing.Process en multiprocessing.Queue te gebruiken. Na een uurtje flink kloppen lukt dit nu ook wel.

Nadeel is, dat queue niet echt een variabele is, maar een communicatiekanaal, wat er (blijkbaar) voor zorgt dat zodra ik data heb en deze in de queue stop, mijn multiprocessing "thread" gestopt wordt, tot deze data uit de queue gehaald wordt.

Is er een alternatief waarmee je wel makkelijk steeds nieuwe data naar je hoofd "thread" kan loodsen?
Ik zat zelf aan een stack te denken, waar ik gewoon continue data in push, en bij het uitlezen pop, en eens in de zoveel tijd, de stack leeg. Maar een stack blijkt niet te werken tussen multiprocessing.Process classes in Python.

Iemand een idee?

[Verwijderd]

Je bent op de hoogte van de global interprenter lock? Ik heb nog nooit met threads gewerkt in python, maar ik heb anderen wel flink horen klagen over het feit dat de GIL multithreading in pyhon nutteloos zou maken.

Als het goed is is een queue asynchroon, tot op zekere hoogte. Als je te veel items in je queue propt zit hij vol en blockt de thread, idem als je uit de queue leest. Als je proces blockt zodra je iets in de queue stopt, dan gebruik je hem blijkbaar verkeerd of is de implementatie van de queue niet geschikt voor deze taak.

[FireDrunk]

Het is ook niet echt bedoeld voor snelheid, maar om meerdere While True loops tegelijk te kunnen draaien.
Als dat allemaal door 1 interpreter afgehandeld wordt, ben ik tevreden.

Ik zag in de multiprocessing.Queue opties geen manier om de queue nonblocking te maken, misschien dat ik iets mis?

[Zoijar]

Ik snap niet helemaal wat je precies wilt. Queue.get_nowait() ?

Overigens kan python idd niet multi-threaden, maar wel multi-processen (waarbij elk proces een eigen interpreter draait) Die kunnen ook data uitwisselen via een shared memory queue. http://docs.python.org/2/library/multiprocessing.html Alleen multi-processing is te zwaar voor bv 100 processes. Aan de andere kant is 100 threads spawnen ook een slecht idee en kan je beter een soort van producer/consumer/work-distributor opzetten met 100 lightweight tasks, en 4 workers in een process op elke core.

[ Voor 30% gewijzigd door Zoijar op 17-11-2013 12:40 ]

[FireDrunk]

Ik heb dat geprobeerd, maar dat leek niet altijd goed te gaan. Probleem is natuurlijk dat ik de data in de queue in zijn geheel wil vervangen (altijd de meest recente data beschikbaar), maar ik heb twee threads die tegelijkertijd in die queue rommelen, maar er zou best-case altijd maar 1 item in die queue zitten.

Als de producer thread de nieuwste data erin zet, zou hij het vorige item er uit moeten halen. Als op dat moment die data door de andere thread opgehaald word, gaat het volgens mij niet goed.

Ik heb dus een soort doorgeefluik nodig, bestaande uit 1 variabele (gewoon een string is prima), die thread-safe is.

[Zoijar]

Makkelijkste is dan een normaal stukje shared memory dat je even locked via een mutex. http://docs.python.org/2/...ization-between-processes Waarschijnlijk wil je bij je data nog een sequence number / time stamp om te zien of het nieuwe data is.

[ Voor 23% gewijzigd door Zoijar op 17-11-2013 12:53 ]

[FireDrunk]

Het is uiteindelijk gelukt via multiprocessing.Manager().Value(unicode,"")

In combinatie met een Lock kan je hier gewoon in schrijven en uit lezen!

Thanks!