@Sirius3: vielen dank für das Beispiel
Ich erwarte Unterschiede in der Zeit, weil hier ja behauptet wird, das eine sei besser geeignet als das andere
Und ich möchte für mich selber sehen, was nun für meine Zwecke am besten ist. Die Zeit ist das einzige, was mir einfällt, was ich messen könnte, um die Unterschiede festzustellen.
Ich möchte die Unterschiede sehen, damit ich entscheiden kann, welches ich nun für mein Skript verwende.
Habe jetzt Thread gewählt und es für mein Zwecke verwendet. Hat ne Weile gedauert, aber jetzt scheint dabei alles zu funktionieren
Wenn du sagst, dass es keine zeitlichen Unterschiede gibt, was ist es dann, was mehr für das Eine und gegen das Andere spricht?
edit1: sehe gerade zu futures nennst du schon einen vorteil, danke
Das war auch mein Gedanke, dass es leichter einzubauen ist (danke an pillmuncher für den Muster Pseudocode). Allerdings schreibt pillmuncher ja auch, dass man tatsächlich aber noch ThreadPoolExecutor.map() verwenden muss, was doch letzlich auf denselben (oder zumindest ähnlich hohen) Aufwand rauslaufen würde (nämlich auf eine funktion außerhalb des linearen Ablaufs zu verweisen), wie die Sache mit Threading, oder nicht?
Mein threading Skript sieht nun übrigens so aus (def parallel befindet sich in der "Boerse2Rock"-Klasse und kann halt jederzeit mit den gewünschten aufgaben aufgerufen werden... noch werden die ergebnisse einfach nur in eine liste geklatscht und geprintet, mal gucken wie ich das dann noch weiter mache) :
Code: Alles auswählen
#sorgt dafür, dass übergebene Aufgaben parallel erledigt werden! (für aufgabennamen siehe multithread klasse)
def parallel(self,aufgabe1, aufgabe2, aufgabe3=0, aufgabe4=0, aufgabe5=0, aufgabe6=0, aufgabe7=0):
print("Zeit direkt bei parallel aufruf: {}".format(uhrzeit()))
aufgabenliste = [aufgabe1, aufgabe2, aufgabe3, aufgabe4, aufgabe5, aufgabe6, aufgabe7]
#jetzt noch alle nullen entfernen
while 0 in aufgabenliste:
aufgabenliste.remove(0)
threads = list(map(Multithread, aufgabenliste))
for thread in threads:
thread.start()
for thread in threads:
thread.join()
print(list(thread.result for thread in threads))
print("Zeit wenn fertig: {}".format(uhrzeit()))
# Klasse zum parallelierisern
class Multithread(threading.Thread):
def __init__(self, aufgabe):
threading.Thread.__init__(self)
self.aufgabe = aufgabe
self.result = None
def run(self):
if self.aufgabe == "MyBalanceEUR_boerse2":
result = Boerse2Rock().get_balance("boerse2","EUR")
if self.aufgabe == "MyBalanceEUR_rock":
result = Boerse2Rock().get_balance("TheRock","EUR")
if self.aufgabe == "FullOrderBook_rock":
result = Boerse2Rock().get_orderbook("TheRock","BTCEUR")
if self.aufgabe == "FullOrderBook_boerse2":
result = Boerse2Rock().get_orderbook("boerse2","BTCEUR",10)
if self.aufgabe == "GetTicker_boerse2":
result = Boerse2Rock().get_ticker_exchangepair("boerse2","BTCEUR")
if self.aufgabe == "GetTicker_rock":
result = Boerse2Rock().get_ticker_exchangepair("TheRock","BTCEUR")
self.result = result
return 1
ich merke gerade, dass die aufgabenart mithilfe von festgelegten Namen festzulegen vllt doch nicht so günstig ist... Hier sind das meiste ja nur Anfragen, die nur wenige Paramenter benötigen. Aber wenn ich nun z.b eine Kauforder einstellen will, muss ich viele Parameter und vorallem auch den Preis nennen. Das funktioniert mit dieser Namensvergabe dann also schonmal nicht.
D.h ich muss ich jetzt überlegen, wie ich etwas parallel laufen lasse, aber dennoch alle gewünschten Paramter übergeben kann...
Fällt euch da was ein? Ich würde jetzt vermutlich auf Klasseninterne Variablen zurückgreifen. Z.b eine self.preis Variable, die kurz vor dem Aufruf von "parallel(kaufebtc_1, kaufebtc_2)" eingestellt wird, damit die dann wissen zu welchem Preis.
