added py files

Author: proquickly

source/modules/lesson07/ThreadingMultiprocessing_part3.rst

@@ -14,6 +14,5 @@ jumbled
 
 2. Try adding a Semaphore to allow 2 threads access at once.
 
-.. TODO:: 
-    Review lock_exercise.zip
+
 

source/modules/lesson07/examples/threading-multiprocessing/integrate.py

@@ -0,0 +1,44 @@
+def f(x):
+    return x**2
+
+
+def integrate(f, a, b, N):
+    s = 0
+    dx = (b - a) / N
+    for i in range(N):
+        s += f(a + i * dx)
+    return s * dx
+
+
+def integrate_f_with_functional_tools(f, a, b, N):
+    dx = (b - a) / N
+    return sum(map(f, ((a + y * dx) for y in range(N)))) * dx
+
+
+
+
+
+
+
+
+
+
+
+
+# imported here so the rest of the code can run without it
+import numpy as np
+
+def integrate_numpy(f, a, b, N):
+    """
+    numpy can be used to "vectorize" the problem
+
+    f must be "numpy comaptible"
+
+    """
+    dx = (b - a) / N
+    i = np.arange(N)
+    s = np.sum(f(a + (i * dx)))
+    return s * dx
+
+
+

source/modules/lesson07/examples/threading-multiprocessing/integrate_threads.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+
+import threading
+import queue
+
+# from integrate.integrate import integrate, f
+from integrate import f, integrate_numpy as integrate
+from decorators import timer
+
+
+@timer
+def threading_integrate(f, a, b, N, thread_count=2):
+    """break work into N chunks"""
+    N_chunk = int(float(N) / thread_count)
+    dx = float(b - a) / thread_count
+
+    results = queue.Queue()
+
+    def worker(*args):
+        results.put(integrate(*args))
+
+    for i in range(thread_count):
+        x0 = dx * i
+        x1 = x0 + dx
+        thread = threading.Thread(target=worker, args=(f, x0, x1, N_chunk))
+        thread.start()
+        print("Thread %s started" % thread.name)
+
+    return sum((results.get() for i in range(thread_count)))
+
+
+if __name__ == "__main__":
+
+    # parameters of the integration
+    a = 0.0
+    b = 10.0
+    N = 10**8
+    thread_count = 1
+
+    print("Numerical solution with N=%(N)d : %(x)f" %
+          {'N': N, 'x': threading_integrate(f, a, b, N, thread_count=thread_count)})
+

source/modules/lesson07/examples/threading-multiprocessing/lock_exercise.zip

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+
+import threading
+import time
+
+
+# create a mutable object that is shared among threads
+class shared:
+    val = 1
+
+
+def func():
+    y = shared.val
+    time.sleep(0.00001)
+    y += 1
+    shared.val = y
+
+
+threads = []
+# with enough threads, there's sufficient overhead to
+# cause a race condition
+for i in range(100):
+    thread = threading.Thread(target=func)
+    threads.append(thread)
+    thread.start()
+
+for thread in threads:
+    thread.join()
+
+print(shared.val)
+

source/modules/lesson07/examples/threading-multiprocessing/race_condition.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python
+
+"""
+Simple example of using a threading.Timer
+
+NOTE: The docstring is out of sync with the __init__!
+      I think it was inherited from the threading.Thread docstring.
+"""
+
+import threading
+import time
+import random
+
+
+def called_once():
+    """
+    this function is designed to be be called once in the future
+    """
+    print("Hey! I just got called! It's now: {}".format(time.asctime()))
+
+
+def called_later(count):
+    """
+    This function is designed to run, and then set up a timer to call
+    itself at a random time in the future
+
+    Note that it is limited to 10 invocations
+    Otherwise, there will always be a background
+    thread running that can not be easily killed
+    (at least on *nix -- Windows may let ^C kill it)
+
+    Try hitting ^C early in the run...
+    """
+
+    print("Hey! I just got called for {}th time! It's now: {}"
+          .format(count, time.asctime()))
+    # this can trigger another invocation
+    interval = random.randint(1, 3)
+    count += 1
+    if count < 10:
+        threading.Timer(interval=interval,
+                        function=called_later,
+                        args=(count,)).start()
+
+
+if __name__ == "__main__":
+    # use the timer...
+
+    # threading.Timer(interval=3, function=called_once).start()
+    # print("After starting the timer")
+    # print("it's now: {}".format(time.asctime()))
+
+    called_later(0)
+
+    # do some stuff:
+    for i in range(100):
+        print("{}: nothing important...".format(i))
+        time.sleep(0.5)
+
+
+
+