cleanup names for dirs

boilerplates-concurrence/README.md

@@ -0,0 +1,3 @@
+### Concurrence in Python
+
+Examples for my Medium article: [Python + Concurrence: A Mnemonic Guide🚦](https://medium.com/python-for-the-utopian/python-concurrence-a-mnemonic-guide-7304867cbfb7).

boilerplates-concurrence/asyncio_simple_example.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python3
+
+import asyncio
+
+
+async def delayed_hello():
+    print('Hello ')
+    await asyncio.sleep(1)
+    print('World!')
+
+
+loop = asyncio.get_event_loop()
+loop.run_until_complete(delayed_hello())
+loop.close()

boilerplates-concurrence/concurrent_future_example.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+
+from time import sleep
+from concurrent.futures import ThreadPoolExecutor
+
+
+def return_after_5_secs(message):
+    sleep(5)
+    return message
+
+
+pool = ThreadPoolExecutor(3)
+future = pool.submit(return_after_5_secs, ('Future message'))
+
+print(future.done())
+
+sleep(5)
+print(future.done())
+print(future.result())

boilerplates-concurrence/daemon_example.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+
+import time
+import sys
+import multiprocessing
+
+
+def daemon():
+    p = multiprocessing.current_process()
+    print('Starting: {}, {}'.format(p.name, p.pid))
+
+    sys.stdout.flush()
+    time.sleep(1)
+    print('Exiting : {}, {}'.format(p.name, p.pid))
+
+    sys.stdout.flush()
+
+
+def non_daemon():
+    p = multiprocessing.current_process()
+    print('Starting: {}, {}'.format(p.name, p.pid))
+
+    sys.stdout.flush()
+    print('Exiting : {}, {}'.format(p.name, p.pid))
+
+    sys.stdout.flush()
+
+
+
+if __name__ == '__main__':
+    d = multiprocessing.Process(name='daemon', target=daemon)
+    d.daemon = True
+
+    n = multiprocessing.Process(name='non-daemon', target=non_daemon)
+    n.daemon = False
+
+    d.start()
+    time.sleep(1)
+    n.start()

boilerplates-concurrence/deadlock_example.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+
+import threading 
+
+l = threading.Lock()
+print("Before first lock acquire.")
+
+l.acquire()
+print("Before second lock acquire.")
+
+l.acquire()
+print("Lock was acquired twice")

boilerplates-concurrence/logging_example.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+
+import sys
+import logging
+import multiprocessing
+
+
+def worker():
+    print('Doing some work...')
+    sys.stdout.flush()
+
+
+multiprocessing.log_to_stderr(logging.DEBUG)
+p = multiprocessing.Process(target=worker)
+p.start()
+p.join()

boilerplates-concurrence/multiprocessing_example.py

@@ -0,0 +1,14 @@
+import time
+import random
+import multiprocessing
+
+
+def worker(n):
+    sleep = random.randrange(1, 10)
+    time.sleep(sleep)
+    print("Worker {}: sleeping for {} seconds.".format(n, sleep))
+
+
+for i in range(5):
+    p = multiprocessing.Process(target=worker, args=(i,))
+    p.start()

boilerplates-concurrence/pool_example.py

@@ -0,0 +1,11 @@
+#!/usr/bin/env python3
+
+from multiprocessing import Pool
+
+
+def f(x):
+    return x*x
+
+
+p = Pool(5)
+print(p.map(f, [1, 2, 3]))

boilerplates-concurrence/race_coditions.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+
+import threading
+
+x = 0     
+COUNT = 10000000
+
+def foo():
+    global x
+    for i in range(COUNT):
+        x += 1
+
+def bar():
+    global x
+    for i in range(COUNT):
+        x -= 1
+
+t1 = threading.Thread(target=foo)
+t2 = threading.Thread(target=bar)
+
+t1.start()
+t2.start()
+
+t1.join()
+t2.join()
+
+print(x)

boilerplates-concurrence/thread_example.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+
+import time
+import random
+import threading
+
+
+def worker(n):
+    sleep = random.randrange(1, 10)
+    time.sleep(sleep)
+    print("Worker {} from {}: sleeping for {} seconds.".format(n, threading.get_ident(), sleep))
+
+
+for i in range(5):
+    t = threading.Thread(target=worker, args=(i,))
+    t.start()

boilerplates-concurrence/threadpool_example.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python3
+
+from time import sleep
+from concurrent.futures import ThreadPoolExecutor
+
+ 
+def return_after_5_secs(message):
+    sleep(5)
+    return message
+ 
+pool = ThreadPoolExecutor(3)
+ 
+future = pool.submit(return_after_5_secs, ("hello"))
+
+print(future.done())
+sleep(5)
+print(future.done())
+print(future.result())

boilerplates-concurrence/threads_with_queues.py

@@ -0,0 +1,19 @@
+from queue import Queue
+from threading import Thread
+
+
+NUM_WORKERS = 4
+task_queue = Queue()
+
+
+def worker():
+    while True:
+        address = task_queue.get()
+        run_function(address)
+        task_queue.task_done()
+
+
+threads = [Thread(target=worker) for _ in range(NUM_WORKERS)]
+[task_queue.put(item) for item in threads]
+[thread.start() for thread in threads]
+task_queue.join()