Das deutsche Python-Forum

Code: Alles auswählen

future = Future(action)       # <-- startet action in einem anderen Thread/Prozess
do some stuff
result = future.get_result()  # <-- falls action fertig ist, bekommt man das Ergebnis sofort, 
                              #     falls nicht, wird gewartet, bis action fertig ist.

Code: Alles auswählen

URLS = ['http://www.foxnews.com/',
        'http://www.cnn.com/',
        'http://europe.wsj.com/',
        'http://www.bbc.co.uk/',
        'http://some-made-up-domain.com/',
        'http://python-forum.de/',
        'http://python-kurs.eu/',
        'http://abc.de/',
        'http://abc.de/',
        'http://abc.de/',
        'http://abd.de/',
        'http://abd.de/',        
        'http://abd.de/',        
        'http://abd.de/',
        'http://abe.de/',
        'http://abe.de/',        
        'http://abe.de/',        
        'http://abe.de/',        
        'http://abf.de/', 
        'http://abf.de/',    
        'http://abf.de/',    
        'http://abf.de/',    
        'http://abf.de/',    
        'http://abh.de/',   
        'http://abh.de/',
        'http://abh.de/',
        'http://abh.de/',
        'http://abh.de/',
        'http://abh.de/',
        'http://abi.de/',
        'http://abi.de/',
        'http://abi.de/',
        'http://abi.de/',
        'http://abi.de/']

Code: Alles auswählen

class Foo(threading.Thread):
    def __init__(self, url):
        threading.Thread.__init__(self)
        self.url = url      
        
    def load_url(self,url, timeout):
        conn = urllib.request.urlopen(url, timeout=timeout)
        return conn.readall()
   
    def run(self):
        try:
            data = self.load_url(self.url,60)
        except Exception as exc:
            print('%r generated an exception: %s' % (self.url, exc))
        else:
            print('%r page is %d bytes' % (self.url, len(data)))
 
if __name__ == "__main__":
    print("Mit THREADING {}".format(uhrzeit()))
    threads = list(map(Foo, URLS))
    for thread in threads:
        thread.start()
   
    for thread in threads:
        thread.join()

    print(uhrzeit())

Code: Alles auswählen

# Retrieve a single page and report the url and contents
def load_url(url, timeout):
    conn = urllib.request.urlopen(url, timeout=timeout)
    return conn.readall()

# We can use a with statement to ensure threads are cleaned up promptly
print("Mit FUTURES {}".format(uhrzeit()))
with concurrent.futures.ThreadPoolExecutor(max_workers=34) as executor:
    # Start the load operations and mark each future with its URL
    future_to_url = {executor.submit(load_url, url, 60): url for url in URLS}
    for future in concurrent.futures.as_completed(future_to_url):
        url = future_to_url[future]
        try:
            data = future.result()
        except Exception as exc:
            print('%r generated an exception: %s' % (url, exc))
        else:
            print('%r page is %d bytes' % (url, len(data)))
print(uhrzeit())

Code: Alles auswählen

import asyncio
import aiohttp

@asyncio.coroutine
def read_url(url):
    conn = yield from aiohttp.request('get', url)
    return url, (yield from conn.read())

def main():
    tasks = [read_url(url) for url in URLS]
    for task in asyncio.as_completed(tasks):
        try:
           url, page = yield from task
           print("%s page is %d bytes" % (url, len(page)))
        except Exception as ext:
           print("Exception: %s" % ext)

loop = asyncio.get_event_loop()
loop.run_until_complete(main())

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

Code: Alles auswählen

fn(*args, **kwargs)

Code: Alles auswählen

future = Future(action)   
get_balance(args1)
get_ticker(args2)
result = future.get_result()

Code: Alles auswählen

class TheTest():

    def __init__(self):
        self.var = None  # da es nicht geht, weiter geht, ohne iwas zu schreiben, definieren wir eine beliebige variable
        # für thetest wird nichts andres gebraucht

    """hier sind auch die ganzen funktionen get_balance usw definiert"""

    def parallel(self,aufgabenliste):
        
        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))    

    def machwas(self):
        self.args1 = ["Kraken","ZEUR"]
        self.args2 = ["TheRock","EUR"]
        self.parallel(["TheTest().get_balance(*args1)","TheTest().get_balance(*args2)"]) 
        # hier weiß ich nicht, welche Namen ich verwenden muss, um auf die in machwas definierten Werte zu kommen.
     
class Multithread(threading.Thread):
    def __init__(self, aufgabe):
        threading.Thread.__init__(self)
       
        self.aufgabe = aufgabe      
        self.result = None  
        
    def run(self):
        result = eval(self.aufgabe)
        self.result = result