Több művelet elvégzése egyszerre, adagolva Pythonban?

Használj olyan nyelvet ami támogatja a többszálú működést. Ha a Python "ügyesen" használja a zárakat még lassabb is lehet. Itt az ideje keresni valami mást vagy hagyni egyszálon az egész (esetleg átrakhatod C-be a kód egy részét).

[link]

Nem igazán értem a kérdést, nem azért akarod párhuzamosítani hogy felgyorsítsd és ne egyenként kelljen "adagolni"? Azt is elfelejtetted leírni hogy mi a hiba pontosan, nehéz úgy segíteni.

Több száz vagy akár több ezer szál indítása nem igen szerencsés dolog, programnyelvtől függetlenül. Ha el is tudna indítani ennyit, olyan overhead lenne hogy a program nem tudna megfelelően működni, főleg olyan feladatoknál ahol egyes szálak futási ideje korlátozva van (ez esetben a válasz idő legyen kisebb mint a packet timeout idő).

A megoldás itt is a mikroszálasítás. Pythonban a modul neve greenlet, de van egy erre épülő networking modul is, amit geventnek neveznek. Telepítsd és használd:

[link]

> Azt értem, hogy a több száz hoszt adatlekérését nem több száz egyszerre futó szálon szeretném végezni, hanem mondjuk egyszerre maximum 10 szál fusson - ha egy szál befejezte a futását, menjen a helyére egy másik új.

Amiről beszélsz az a thread pool, és az is a fentebb említett gevent része. A lényege hogy csinálsz egy meghatározott méretű pool-t amiben futnak a szálak és ha az egyik szál befejezte a futást kilép a pool-ból hogy egy másik szál be tudjon lépni a helyére.

Példa a gevent használatára:

from gevent import monkey

#hogy minden stdlib együttműködjön a greenlettel, pl. urllib

monkey.patch_all()

from gevent.pool import Pool

def valami_fuggveny(url):

> #a függvenyed ami adatokat kérdez le a hosztoktól

> pass

#a hosztok címe

urls = [' [link] ' [link] ' [link]

#egyszerre max 20 szál legyen a pool-ban

pool = Pool(20)

#átadod az url-eket egyenként a függvényednek

pool.map(valami_fuggveny, urls)

Elég egyszerű és nagyon rugalmas tud lenni. Alapból még a pool sem kéne mert ezek mikroszálak, nem igazi szálak aminek közel sincs akkora overheadje (bár 50-100 fölött azért itt is érdemes), ráadásul még szálbiztos is. Érdemes olvasgatni a dokumentációját, vagy egy tutorialt róla.

Két szálat indítani (az egyik olvas és a másik feldolgoz)? Pont ez a két dolog nem tud átlapolódni. A Pythonban csak a párhuzamos IO műveletek tudnak egyidejűleg végrehajtódni. Tehát nyugodtan elvégezheted egy szálon is és megspórolod a zárkezelés miatti oda-vissza váltást.

A kérdés nem a szálkezelésről szólt, hanem hogyan gyorsítsuk fel a programot (komoly különbség!). Ha pedig valóban jól tudná a szálakat kezelni a Python (nincs így), akkor annyi szálat kellene elindítani ammennyi számítási egységed van (mivel így a legnagyobb az áteresztőképesség). Pl. 4 mag esetén egyszerre 4 választ kéne egyidejűleg feldolgoznod. Itt legfeljebb a sok letöltést oldhatod meg több szállal (ami az IO műveletek miatt átlapolódik), majd feldolgozhatod egy szálról.

Tuti, hogy Pythonban akarod ezt megoldani?

Marmint oke, szalkezelessel megoldhato lenne, hogy van 10 worker szal es hajra, dolgozzanak, de ahogy irtak annyival nem biztos, hogy sokkal jobb lenne az eredmeny.

Go-ban ez mondjuk valoszinulag egy par soros koddal megoldhato lenne es garantaltan sokkal gyorsabban futna. De persze teljesen mas nyelv, amit tanulni kell...