Valamit nagyon elrontottam (Python)? Tanulom a párhuzamos feladat végrehajtást. A program megakad a p.join() sornál. Azt egyszer végrehajtja és vár.
from multiprocessing import Lock, Process, Queue, current_process
import time
import queue # imported for using queue.Empty exception
import math
import os
from datetime import datetime
def do_job(tasks_to_accomplish, tasks_that_are_done,primes,blocksize):
while True:
try:
''' try to get task from the queue. get_nowait() function will
raise queue.Empty exception if the queue is empty.
queue(False) function would do the same task also.
'''
task = tasks_to_accomplish.get_nowait()
except queue.Empty:
break
else:
'''
if no exception has been raised, add the task completion
message to task_that_are_done queue
'''
def rosta(bs,kor):
eredm=[]
def IsPrime(n):
prime=True
if n>17 :
maximum=int(math.sqrt(n))+1
else:
maximum=n
for i in primes:
if n>maximum : break
if n%i==0:
prime=False
break
return prime
for pr in range((kor-1)*bs+1,kor*bs,2):
if IsPrime(pr):eredm.append(pr)
return eredm
tmp=rosta(blocksize,task)
tasks_that_are_done.put(tmp)
time.sleep(.5)
return True
def main():
primes=[2,3,5,7,11,13,17]
blocksize=1
for i in primes:blocksize=blocksize*i
number_of_task = 5
number_of_processes = 5
tasks_to_accomplish = Queue()
tasks_that_are_done = Queue()
processes = []
def IsPrime(n):
prime=True
if n>17 :
maximum=int(math.sqrt(n))+1
else:
maximum=n
for i in primes:
if i>maximum :break
if n%i==0:
prime=False
break
return prime
for pr in range(21,blocksize+1,2):
if IsPrime(pr):primes.append(pr)
#print(primes)
for i in range(1,number_of_task+1):
tasks_to_accomplish.put(i)
# creating processes
for w in range(number_of_processes):
p = Process(target=do_job, args=(tasks_to_accomplish, tasks_that_are_done,primes,blocksize))
processes.append(p)
p.start()
# completing process
for p in processes:
print("qwe")
p.join()
print('asd')
# print the output
while not tasks_that_are_done.empty():
print(tasks_that_are_done.get()[0])
return True
if __name__ == '__main__':
main()
válasza:Semmi baj, a lényeg hogy 2x ugyanabba a sz@rba ne lépj bele.
Egyébként miért mindjárt párhuzamos feldolgozás a legközelebbi mérföldkő?
Ha külön nincs kód szinten biztosítva az se garantált hogy később elindított process később kezdi el a végrehajtást meg az se garatnált hogy indítási sorrendbe fejeződnek be még ha ugyanazt csinálják akkor se. Szálak is vannak különben, ezek a szálakra is igazak. Viszont a szálak könnyebb súlyúak mint a processek, azok egy processen belül vannak. Szálak esetében kevesebb overhead van, meg ugyanazokat a változókat objektumokat érik el melyek egy processen belül vannak. Ha b egy boolean változó akkor mindig igaz klasszikusan a not b and b , ha erre nem ügyeltünk akkor ugyan kis valószínűséggel de lehet ez hamis is. Kiértékelésnél not b az True azaz b az False majd egy másik szálon b-t pont akkor True-ra változtatja. Bár lehet az ütemező úgy dolgozik, hogy ilyen sose fordul elő az adott platformon az adott python verzión, de erre nem kell számítani hanem ilyen anomáliákat eleve el kell kerülni úgy kell tervezni. Olyan mondjuk lehet már gyakorlatilag is ha nem jól van implementálva, hogy if (b) { ... } ott csinál valami hosszabb dolgot és közbe a másik szál módosít b értékébe, ezáltal meg rendellenesen befolyásolja a másik szálat.
Ugyanakkor meg van a létjososultsága a szálaknak is a processeknek is párhuzamos feldolgozásnál, több számítógépes párhuzamos feldolgozásról nem is beszélve.
válasza:
válasza:Ahogy én néztem ezt a kódot, nem a prímszám keresés volt itt párhuzamosítva, hanem ugyan az a keresés futott le az összes szálon. De ahogy a kérdező is írta, kissé kusza volt a kód.
Ilyen esetben érdemes valami nagyon-nagyon alapszintű eljárás párhuzamosításával kezdeni és azon alaposan letesztelni. Majd az egészet elrejteni valami osztályba, hogy nem is lássa többet az ember. Végül jöhet a komolyabb függvény, aminek a végrehajtását párhuzamosítani akarod. De akkor már csak arra a függvényre fókuszálsz és nem magára a párhuzamosítás implementációjára.
Mondjuk, amikor tervezed az egész hóbelevancot, akkor végig kell gondolni, hogy a process mely lépéseit lehet párhuzamosítani, és ennek fényében kell elkezdeni a párhuzamosítást.
Kapcsolódó kérdések:
Minden jog fenntartva © 2024, www.gyakorikerdesek.hu
GYIK | Szabályzat | Jogi nyilatkozat | Adatvédelem | Cookie beállítások | WebMinute Kft. | Facebook | Kapcsolat: info(kukac)gyakorikerdesek.hu
Ha kifogással szeretne élni valamely tartalommal kapcsolatban, kérjük jelezze e-mailes elérhetőségünkön!