Compare commits
6 Commits
Author | SHA1 | Date | |
---|---|---|---|
![]() |
0982608da1 | ||
![]() |
b580f7fd5b | ||
f7a5db9f39 | |||
298151634d | |||
fc8b033215 | |||
535087c248 |
@@ -14,4 +14,6 @@ CC-BY-SA Olli Graf
|
||||
| 7 | Module|
|
||||
| 8 | Exceptions|
|
||||
| 9 | Typkonvertierung|
|
||||
|10 | Dateien|
|
||||
|11 | Datum und Zeit|
|
||||
|
||||
|
46
multithread.py
Normal file
46
multithread.py
Normal file
@@ -0,0 +1,46 @@
|
||||
from timeit import default_timer as timer
|
||||
import time
|
||||
import threading
|
||||
|
||||
def calc_square(numbers, verbose=False):
|
||||
for n in range(1,numbers):
|
||||
q= n*n
|
||||
if verbose:
|
||||
print(f'\n{n} ^ 2 = {q}')
|
||||
time.sleep(0.1)
|
||||
|
||||
def calc_cube(numbers,verbose=False):
|
||||
for n in range(1,numbers):
|
||||
k = n*n*n
|
||||
if verbose:
|
||||
print(f'\n{n} ^ 3 = {k}')
|
||||
time.sleep(0.1)
|
||||
|
||||
start = timer()
|
||||
|
||||
thread_square = threading.Thread(target=calc_square, args=(100,True))
|
||||
thread_cube = threading.Thread(target=calc_cube, args=(100,True))
|
||||
|
||||
thread_cube.start()
|
||||
thread_square.start()
|
||||
|
||||
thread_cube.join()
|
||||
thread_square.join()
|
||||
ende = timer()
|
||||
differenz_mit_print = ende - start
|
||||
print(f'Zeit mit print():{differenz_mit_print}s')
|
||||
|
||||
start = timer()
|
||||
|
||||
thread_square = threading.Thread(target=calc_square, args=(100,False))
|
||||
thread_cube = threading.Thread(target=calc_cube, args=(100,False))
|
||||
|
||||
thread_cube.start()
|
||||
thread_square.start()
|
||||
|
||||
thread_cube.join()
|
||||
thread_square.join()
|
||||
|
||||
ende = timer()
|
||||
differenz_ohne_print = ende - start
|
||||
print(f'Zeit ohne print():{differenz_ohne_print}s')
|
45
race_condition_async.py
Normal file
45
race_condition_async.py
Normal file
@@ -0,0 +1,45 @@
|
||||
import asyncio
|
||||
import random
|
||||
import time
|
||||
|
||||
gesamtwert = 0
|
||||
message = ''
|
||||
|
||||
|
||||
async def calculate_sum(lock, thread_nummer):
|
||||
global gesamtwert
|
||||
global message
|
||||
|
||||
for i in range(100 + thread_nummer):
|
||||
async with lock:
|
||||
zwischen = gesamtwert
|
||||
#Zufällige Wartezeit zwischen 0,1s und 0,5s
|
||||
wartezeit = random.randint(1,5+thread_nummer)
|
||||
time.sleep(0.1 * wartezeit)
|
||||
|
||||
zwischen += 1
|
||||
|
||||
async with lock:
|
||||
gesamtwert = zwischen
|
||||
|
||||
message = f'Thread {thread_nummer} fertig'
|
||||
print(f'Thread + {thread_nummer} abgearbeitet.')
|
||||
|
||||
async def main():
|
||||
|
||||
#async Lock erzeugen
|
||||
lock = asyncio.Lock()
|
||||
|
||||
# drei Threads starten, um die Summe der Zahlen zu berechnen
|
||||
|
||||
threads = [asyncio.create_task(calculate_sum(lock, _+1)) for _ in range(3)]
|
||||
|
||||
#Warten auf alle Threads
|
||||
await asyncio.gather(*threads)
|
||||
|
||||
print(f'gesamtwert={gesamtwert}')
|
||||
print(f'message={message}')
|
||||
|
||||
if __name__ == '__main__':
|
||||
asyncio.run(main())
|
||||
|
BIN
teil10/__pycache__/namen.cpython-39.pyc
Normal file
BIN
teil10/__pycache__/namen.cpython-39.pyc
Normal file
Binary file not shown.
5
teil10/namen.csv
Normal file
5
teil10/namen.csv
Normal file
@@ -0,0 +1,5 @@
|
||||
Skinner,Seymour
|
||||
Largo,Dewey
|
||||
Krabappel,Edna
|
||||
Hoover,Elisabeth
|
||||
Chalmers,Gary
|
|
1
teil10/namen.py
Normal file
1
teil10/namen.py
Normal file
@@ -0,0 +1 @@
|
||||
namen = ["Homer", "Marge", "Bart"]
|
3
teil10/namen.txt
Normal file
3
teil10/namen.txt
Normal file
@@ -0,0 +1,3 @@
|
||||
Homer
|
||||
Marge
|
||||
Bart
|
29
teil10/read_csv.py
Normal file
29
teil10/read_csv.py
Normal file
@@ -0,0 +1,29 @@
|
||||
school = []
|
||||
class Lehrer():
|
||||
|
||||
def __init__(self, vorname, name):
|
||||
self.vorname = vorname
|
||||
self.name = name
|
||||
|
||||
def __str__(self):
|
||||
return f'{self.vorname} {self.name}'
|
||||
|
||||
|
||||
try:
|
||||
|
||||
with open('namen.csv','r') as f:
|
||||
for line in f:
|
||||
splitted = line.strip().split(',')
|
||||
name = splitted[0]
|
||||
vorname = splitted[1]
|
||||
|
||||
lehrer = Lehrer(vorname,name)
|
||||
school.append(lehrer)
|
||||
|
||||
|
||||
except IOError as x:
|
||||
print(f'I/O-Fehler: {x}')
|
||||
|
||||
print(school)
|
||||
print(school[0])
|
||||
print(school[3])
|
17
teil10/read_file.py
Normal file
17
teil10/read_file.py
Normal file
@@ -0,0 +1,17 @@
|
||||
namen = []
|
||||
|
||||
try:
|
||||
f = open('namen.txt','r')
|
||||
#f = open('namen.txt','r',encoding='utf-8')
|
||||
|
||||
for line in f:
|
||||
namen.append(line)
|
||||
# namen.append(line.strip())
|
||||
except IOError as x:
|
||||
print(f'I/O-Fehler: {x}')
|
||||
finally:
|
||||
if f != None:
|
||||
f.close()
|
||||
|
||||
|
||||
print(namen)
|
15
teil10/write_file.py
Normal file
15
teil10/write_file.py
Normal file
@@ -0,0 +1,15 @@
|
||||
from namen import namen
|
||||
|
||||
f = open('namen.txt','w')
|
||||
|
||||
try:
|
||||
for name in namen:
|
||||
f.write(f'{name}\n')
|
||||
except IOError as err:
|
||||
print(f'I/O-Fehler {err}')
|
||||
finally:
|
||||
if f != None:
|
||||
f.close()
|
||||
|
||||
|
||||
|
12
teil10/write_file_with.py
Normal file
12
teil10/write_file_with.py
Normal file
@@ -0,0 +1,12 @@
|
||||
from namen import namen
|
||||
|
||||
|
||||
try:
|
||||
with open('namen.txt','w') as f:
|
||||
for name in namen:
|
||||
f.write(f'{name}\n')
|
||||
except IOError as err:
|
||||
print(f'I/O-Fehler {err}')
|
||||
|
||||
|
||||
|
10
teil11/create_datetime.py
Normal file
10
teil11/create_datetime.py
Normal file
@@ -0,0 +1,10 @@
|
||||
from datetime import datetime
|
||||
|
||||
datum = datetime.strptime('12.12.2002', '%d.%m.%Y')
|
||||
|
||||
print(f'Jahr: {datum.year}')
|
||||
print(f'Monat: {datum.month}')
|
||||
print(f'Tag: {datum.day}')
|
||||
|
||||
print(datum)
|
||||
|
9
teil11/currentdate.py
Normal file
9
teil11/currentdate.py
Normal file
@@ -0,0 +1,9 @@
|
||||
from datetime import datetime
|
||||
|
||||
heute = datetime.now()
|
||||
|
||||
print(type(heute))
|
||||
print(heute)
|
||||
print(heute.time())
|
||||
print(heute.date())
|
||||
|
10
teil11/formatted_date.py
Normal file
10
teil11/formatted_date.py
Normal file
@@ -0,0 +1,10 @@
|
||||
from datetime import datetime
|
||||
|
||||
heute = datetime.now()
|
||||
|
||||
print(type(heute))
|
||||
print(heute.strftime('%c %X'))
|
||||
print(heute.time().strftime('%X'))
|
||||
print(heute.date().strftime('%x'))
|
||||
print(heute.strftime('%d.%m.%y %H:%M'))
|
||||
|
34
teil11/zeitmessung.py
Normal file
34
teil11/zeitmessung.py
Normal file
@@ -0,0 +1,34 @@
|
||||
from timeit import default_timer as timer
|
||||
import time
|
||||
|
||||
def calc_square(numbers, verbose=False):
|
||||
for n in range(1,numbers):
|
||||
q= n*n
|
||||
if verbose:
|
||||
print(f'\n{n} ^ 2 = {q}')
|
||||
time.sleep(0.1)
|
||||
|
||||
def calc_cube(numbers,verbose=False):
|
||||
for n in range(1,numbers):
|
||||
k = n*n*n
|
||||
if verbose:
|
||||
print(f'\n{n} ^ 3 = {k}')
|
||||
time.sleep(0.1)
|
||||
|
||||
start = timer()
|
||||
|
||||
calc_square(100,True)
|
||||
calc_cube(100,True)
|
||||
|
||||
ende = timer()
|
||||
differenz = ende - start
|
||||
print(f'Zeit mit print():{differenz}s')
|
||||
|
||||
start = timer()
|
||||
|
||||
calc_square(100)
|
||||
calc_cube(100)
|
||||
|
||||
ende = timer()
|
||||
differenz = ende - start
|
||||
print(f'Zeit ohne print():{differenz}s')
|
4004
teil12/multi_write.log
Normal file
4004
teil12/multi_write.log
Normal file
File diff suppressed because it is too large
Load Diff
32
teil12/multi_write.py
Normal file
32
teil12/multi_write.py
Normal file
@@ -0,0 +1,32 @@
|
||||
import threading
|
||||
import logging
|
||||
|
||||
logging.basicConfig(
|
||||
format='%(asctime)-15s [%(levelname)s] %(funcName)s: %(message)s',
|
||||
filename='multi_write.log',
|
||||
level=logging.DEBUG)
|
||||
|
||||
datei = open('zahlen.txt','w')
|
||||
|
||||
def write_number(zahl):
|
||||
|
||||
for i in range(0,1000):
|
||||
logging.debug(f'Thread {zahl}/schreibe {i}')
|
||||
datei.write(f'{i}:{zahl}\n')
|
||||
datei.flush()
|
||||
|
||||
thread_1 = threading.Thread(target=write_number,args=(1,))
|
||||
thread_2 = threading.Thread(target=write_number,args=(2,))
|
||||
|
||||
logging.debug('starte Thread 1')
|
||||
thread_1.start()
|
||||
logging.debug('starte Thread 2')
|
||||
thread_2.start()
|
||||
|
||||
|
||||
thread_1.join()
|
||||
thread_2.join()
|
||||
|
||||
|
||||
|
||||
|
46
teil12/multithreading.py
Normal file
46
teil12/multithreading.py
Normal file
@@ -0,0 +1,46 @@
|
||||
from timeit import default_timer as timer
|
||||
import time
|
||||
import threading
|
||||
|
||||
def calc_square(numbers, verbose=False):
|
||||
for n in range(1,numbers):
|
||||
q= n*n
|
||||
if verbose:
|
||||
print(f'\n{n} ^ 2 = {q}')
|
||||
time.sleep(0.1)
|
||||
|
||||
def calc_cube(numbers,verbose=False):
|
||||
for n in range(1,numbers):
|
||||
k = n*n*n
|
||||
if verbose:
|
||||
print(f'\n{n} ^ 3 = {k}')
|
||||
time.sleep(0.1)
|
||||
|
||||
start = timer()
|
||||
|
||||
thread_square = threading.Thread(target=calc_square, args=(100,True))
|
||||
thread_cube = threading.Thread(target=calc_cube, args=(100,True))
|
||||
|
||||
thread_cube.start()
|
||||
thread_square.start()
|
||||
|
||||
thread_cube.join()
|
||||
thread_square.join()
|
||||
ende = timer()
|
||||
differenz_mit_print = ende - start
|
||||
print(f'Zeit mit print():{differenz_mit_print}s')
|
||||
|
||||
start = timer()
|
||||
|
||||
thread_square = threading.Thread(target=calc_square, args=(100,False))
|
||||
thread_cube = threading.Thread(target=calc_cube, args=(100,False))
|
||||
|
||||
thread_cube.start()
|
||||
thread_square.start()
|
||||
|
||||
thread_cube.join()
|
||||
thread_square.join()
|
||||
|
||||
ende = timer()
|
||||
differenz_ohne_print = ende - start
|
||||
print(f'Zeit ohne print():{differenz_ohne_print}s')
|
52
teil12/pool.py
Normal file
52
teil12/pool.py
Normal file
@@ -0,0 +1,52 @@
|
||||
# encoding: UTF-8
|
||||
from timeit import default_timer as timer
|
||||
import datetime
|
||||
import multiprocessing
|
||||
import time
|
||||
import random
|
||||
|
||||
from multiprocessing import Pool
|
||||
|
||||
def func1(*args, **kwargs):
|
||||
sleep_time = random.randint(3, 6)
|
||||
print(f'Prozess : {multiprocessing.current_process().name}\tFunktion : func1\tArgs:{args}\tgeschlafen {sleep_time} \tZeit : {datetime.datetime.now()}\n')
|
||||
print("Keyword Args from func1: %s" % kwargs)
|
||||
time.sleep(sleep_time)
|
||||
print(f'{multiprocessing.current_process().name}\t func1 fertig: {datetime.datetime.now()}\n')
|
||||
return sum(*args)
|
||||
|
||||
def func2(*args):
|
||||
sleep_time = random.randint(7, 10)
|
||||
print(f'Prozess : {multiprocessing.current_process().name}\tFunktion : func2\tArgs:{args}\tgeschlafen {sleep_time} \tZeit : {datetime.datetime.now()}\n')
|
||||
time.sleep(sleep_time)
|
||||
print(f'{multiprocessing.current_process().name}\t func2 fertig: {datetime.datetime.now()}\n')
|
||||
return sum(*args)
|
||||
|
||||
def func3(*args):
|
||||
sleep_time = random.randint(0, 3)
|
||||
print(f'Prozess : {multiprocessing.current_process().name}\tFunktion : func3\ttArgs:{args}\tgeschlafen {sleep_time} \tZeit : {datetime.datetime.now()}\n')
|
||||
time.sleep(sleep_time)
|
||||
print(f'{multiprocessing.current_process().name}\t func3 fertig: {datetime.datetime.now()}\n')
|
||||
return sum(*args)
|
||||
|
||||
def smap(f, *arg):
|
||||
if len(arg) == 2:
|
||||
args, kwargs = arg
|
||||
return f(list(args), **kwargs)
|
||||
elif len(arg) == 1:
|
||||
args = arg
|
||||
return f(*args)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
start = timer()
|
||||
with Pool(processes=3) as pool:
|
||||
result = pool.starmap(smap, [(func1, [1,2,3],{'a':123, 'b':456}), (func2, [11,22,33]), (func3, [111,222,333])])
|
||||
print(f'Ergebnis: {result}')
|
||||
|
||||
ende = timer()
|
||||
diff = ende - start
|
||||
print(f'Ausführzeit: {diff}s')
|
||||
|
||||
|
12
teil12/pool2.py
Normal file
12
teil12/pool2.py
Normal file
@@ -0,0 +1,12 @@
|
||||
# Quelle: https://stackoverflow.com/questions/35528093/multithreading-in-python-with-a-threadpool
|
||||
from multiprocessing import Pool
|
||||
import sys
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
job_list = [range(10000000)]*6
|
||||
|
||||
print(f'{job_list}')
|
||||
p = Pool(2)
|
||||
print("Parallel map")
|
||||
print(p.map(sum, job_list))
|
20
teil12/pool3.py
Normal file
20
teil12/pool3.py
Normal file
@@ -0,0 +1,20 @@
|
||||
# Quelle: https://www.codesdope.com/blog/article/multiprocessing-using-pool-in-python/
|
||||
import time
|
||||
from multiprocessing import Pool
|
||||
|
||||
|
||||
def square(x):
|
||||
print(f"start process:{x}")
|
||||
square = x * x
|
||||
print(f"square {x}:{square}")
|
||||
time.sleep(1)
|
||||
print(f"end process:{x}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
starttime = time.time()
|
||||
pool = Pool()
|
||||
pool.map(square, range(0, 5))
|
||||
pool.close()
|
||||
endtime = time.time()
|
||||
print(f"Time taken {endtime-starttime} seconds")
|
80
teil12/pool_squares.py
Normal file
80
teil12/pool_squares.py
Normal file
@@ -0,0 +1,80 @@
|
||||
#encoding: UTF-8
|
||||
|
||||
import datetime
|
||||
from timeit import default_timer as timer
|
||||
import multiprocessing
|
||||
import time
|
||||
import random
|
||||
from multiprocessing import Pool
|
||||
|
||||
__verbose__ = False
|
||||
|
||||
# gibt den String s nur aus, wenn __verbose__ True ist.
|
||||
def print_verbose(s):
|
||||
if __verbose__:
|
||||
print(s)
|
||||
|
||||
# Arbeitsfunktion läuft in der Zahlenliste von start bis ende
|
||||
# und summiert die Quadratzahlen in dem Bereich auf.
|
||||
# Die Methode wird in jedem Prozess mit unterschiedlichen Werten
|
||||
# für start und ende abgearbeitet.
|
||||
def calc_sum_square(zahlen, *args,**kwargs):
|
||||
print(f'calc_sum_square() {args}')
|
||||
time.sleep(1.0)
|
||||
start = kwargs['start']
|
||||
ende = kwargs['end']
|
||||
threadnr = kwargs['threadnr']
|
||||
summe = 0
|
||||
|
||||
print_verbose(f'von {start} bis {ende}')
|
||||
for n in range(start,ende):
|
||||
i = zahlen[n]
|
||||
print_verbose(f'Berechnung:{threadnr}: {i}, {i*i}')
|
||||
summe = summe + i*i
|
||||
|
||||
return summe
|
||||
|
||||
# Diese Methode wird initial pro Prozess von der Poolsteuerung aufgerufen und
|
||||
# steuert die Verteilung der Parameter.
|
||||
# f ist der Zeiger auf die aufzurufende Methode
|
||||
# *arg wnthält das Tupel mit den Argumenten
|
||||
#
|
||||
def smap(f, *arg):
|
||||
|
||||
# Auflösen des Tupels: args enthält die Liste mit den Zahlen,
|
||||
# kwarg das Dictionary mit den Parametern für jeden Prozess
|
||||
args, kwargs = arg
|
||||
|
||||
# Aufruf der übergebenen Funktion mit den Parametern
|
||||
return f(args, **kwargs)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
|
||||
start = timer()
|
||||
# Liste mit 10 Mio Integerzahlen anlegen.
|
||||
zahlen = [i for i in range(10000000)]
|
||||
ende = timer()
|
||||
print(f'Zahlenliste erzeugt in {ende-start}s')
|
||||
|
||||
split = int(len(zahlen) / 3)
|
||||
print_verbose(f'split={split}')
|
||||
time.sleep(1.0)
|
||||
|
||||
start = timer()
|
||||
# Pool mit drei Prozesssen
|
||||
with Pool(processes=3) as pool:
|
||||
# Die Methode pool.starmap() bekommt neben der aufzurufenden Methode smap() eine Liste von Tupeln.
|
||||
# Jedes Tupel enthält pro Prozess die auszuführende Methode, die Liste mit den Zahlen und ein Dictionary mit
|
||||
# den Parametern 'threadnr', 'start' und 'end'
|
||||
# starmap() wartet solange, bis alle drei Teilprozesse beendet sind und gibt dann eine Liste mit den return Werten
|
||||
# zurück.
|
||||
result = pool.starmap(smap, [(calc_sum_square, zahlen, {'threadnr':1,'start':0, 'end':split}), (calc_sum_square, zahlen, {'threadnr':2,'start':split+1,'end':split*2}), (calc_sum_square, zahlen,{'threadnr':3,'start':(split*2)+1,'end':split*3})])
|
||||
print(f'Ergebnis: {result}')
|
||||
ende = timer()
|
||||
print(f'Ausführzeit: {ende-start}s')
|
||||
|
||||
|
||||
|
||||
|
14
teil12/pools.py
Normal file
14
teil12/pools.py
Normal file
@@ -0,0 +1,14 @@
|
||||
from multiprocessing import Pool
|
||||
import time
|
||||
|
||||
def calculate_square(n):
|
||||
return n*n
|
||||
|
||||
if __name__ == "__main__":
|
||||
starttime = time.time()
|
||||
pool = Pool()
|
||||
pool.map(calculate_square, range(0, 5))
|
||||
pool.close()
|
||||
endtime = time.time()
|
||||
print(f"Time taken {endtime-starttime} seconds")
|
||||
|
37
teil12/race_condition.py
Normal file
37
teil12/race_condition.py
Normal file
@@ -0,0 +1,37 @@
|
||||
import threading
|
||||
import time
|
||||
import random
|
||||
|
||||
gesamtwert = 0
|
||||
message = ''
|
||||
|
||||
def calculate_sum(thread_nummer):
|
||||
global gesamtwert
|
||||
global message
|
||||
|
||||
for i in range(100 + thread_nummer):
|
||||
zwischen = gesamtwert
|
||||
#Zufällige Wartezeit zwischen 0,1s und 0,5s
|
||||
wartezeit = random.randint(1,5+thread_nummer)
|
||||
time.sleep(0.1 * wartezeit)
|
||||
|
||||
zwischen += 1
|
||||
gesamtwert = zwischen
|
||||
message = f'Thread {thread_nummer} fertig'
|
||||
print(f'Thread + {thread_nummer} abgearbeitet.')
|
||||
|
||||
# zwei Threads starten, um die Summe der Zahlen zu berechnen
|
||||
gesamtwert = 0
|
||||
t1 = threading.Thread(target=calculate_sum, args=(1,))
|
||||
t2 = threading.Thread(target=calculate_sum, args=(2,))
|
||||
t3 = threading.Thread(target=calculate_sum, args=(3,))
|
||||
t1.start()
|
||||
t2.start()
|
||||
t3.start()
|
||||
t1.join()
|
||||
t3.join()
|
||||
t2.join()
|
||||
|
||||
|
||||
print(f'gesamtwert={gesamtwert}')
|
||||
print(f'message={message}')
|
44
teil12/race_condition_asyncio.py
Normal file
44
teil12/race_condition_asyncio.py
Normal file
@@ -0,0 +1,44 @@
|
||||
import asyncio
|
||||
import random
|
||||
import time
|
||||
|
||||
gesamtwert = 0
|
||||
message = ''
|
||||
|
||||
|
||||
async def calculate_sum(lock, thread_nummer):
|
||||
global gesamtwert
|
||||
global message
|
||||
|
||||
for i in range(100 + thread_nummer):
|
||||
async with lock:
|
||||
zwischen = gesamtwert
|
||||
#Zufällige Wartezeit zwischen 0,1s und 0,5s
|
||||
wartezeit = random.randint(1,5+thread_nummer)
|
||||
time.sleep(0.1 * wartezeit)
|
||||
|
||||
zwischen += 1
|
||||
|
||||
async with lock:
|
||||
gesamtwert = zwischen
|
||||
|
||||
message = f'Thread {thread_nummer} fertig'
|
||||
print(f'Thread + {thread_nummer} abgearbeitet.')
|
||||
|
||||
async def main():
|
||||
|
||||
#async Lock erzeugen
|
||||
lock = asyncio.Lock()
|
||||
|
||||
# drei Threads starten, um die Summe der Zahlen zu berechnen
|
||||
|
||||
threads = [asyncio.create_task(calculate_sum(lock, _+1)) for _ in range(3)]
|
||||
|
||||
#Warten auf alle Threads
|
||||
await asyncio.gather(*threads)
|
||||
|
||||
print(f'gesamtwert={gesamtwert}')
|
||||
print(f'message={message}')
|
||||
|
||||
if __name__ == '__main__':
|
||||
asyncio.run(main())
|
43
teil12/race_condition_lock.py
Normal file
43
teil12/race_condition_lock.py
Normal file
@@ -0,0 +1,43 @@
|
||||
import threading
|
||||
import time
|
||||
import random
|
||||
|
||||
gesamtwert = 0
|
||||
message = ''
|
||||
lock = threading.Lock()
|
||||
|
||||
|
||||
def calculate_sum(thread_nummer,lock):
|
||||
global gesamtwert
|
||||
global message
|
||||
|
||||
for i in range(100 + thread_nummer):
|
||||
with lock:
|
||||
zwischen = gesamtwert
|
||||
#Zufällige Wartezeit zwischen 0,1s und 0,5s
|
||||
wartezeit = random.randint(1,5+thread_nummer)
|
||||
time.sleep(0.1 * wartezeit)
|
||||
|
||||
zwischen += 1
|
||||
|
||||
with lock:
|
||||
gesamtwert = zwischen
|
||||
|
||||
message = f'Thread {thread_nummer} fertig'
|
||||
print(f'Thread + {thread_nummer} abgearbeitet.')
|
||||
|
||||
# zwei Threads starten, um die Summe der Zahlen zu berechnen
|
||||
gesamtwert = 0
|
||||
t1 = threading.Thread(target=calculate_sum, args=(1,lock,))
|
||||
t2 = threading.Thread(target=calculate_sum, args=(2,lock,))
|
||||
t3 = threading.Thread(target=calculate_sum, args=(3,lock,))
|
||||
t1.start()
|
||||
t2.start()
|
||||
t3.start()
|
||||
t1.join()
|
||||
t3.join()
|
||||
t2.join()
|
||||
|
||||
|
||||
print(f'gesamtwert={gesamtwert}')
|
||||
print(f'message={message}')
|
37
teil12/threadpools.py
Normal file
37
teil12/threadpools.py
Normal file
@@ -0,0 +1,37 @@
|
||||
import concurrent.futures
|
||||
import random
|
||||
import time
|
||||
|
||||
gesamtwert = 0
|
||||
message = ''
|
||||
|
||||
|
||||
def calculate_sum(thread_nummer):
|
||||
global gesamtwert
|
||||
global message
|
||||
|
||||
for i in range(100 + thread_nummer):
|
||||
zwischen = gesamtwert
|
||||
#Zufällige Wartezeit zwischen 0,1s und 0,5s
|
||||
wartezeit = random.randint(1,5+thread_nummer)
|
||||
time.sleep(0.1 * wartezeit)
|
||||
|
||||
zwischen += 1
|
||||
|
||||
gesamtwert = zwischen
|
||||
|
||||
message = f'Thread {thread_nummer} fertig'
|
||||
print(f'Thread + {thread_nummer} abgearbeitet.')
|
||||
|
||||
def main():
|
||||
|
||||
with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
|
||||
threads = [executor.submit(calculate_sum, i+1) for i in range(3)]
|
||||
|
||||
results = [t.result() for t in threads]
|
||||
|
||||
print(f'gesamtwert={gesamtwert}')
|
||||
print(f'message={message}')
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
Reference in New Issue
Block a user