The main goal of these tutorials series is learning to deal with python source code using the new concepts of execution in python 3.
When two or more events
are concurrent it means that they are happening at the same time.
Concurrent programming is not equivalent to
parallel execution.
In computing,
concurrency is the execution of pieces of work or tasks by a computer at the same time.
Concurrency is a property which more than one operation can be run
simultaneously.
When multiple computations or operations are carried out at the same time or in parallel with the goal of speeding up the computation process then this process is named
parallelism.
Parallelism is a property which operations are actually being run simultaneously using the
multiprocessing.
Multiprocessing, on the other hand, involves utilizing two or more processor units on a computer to achieve parallelism.
Multithreading is a property that refers to the ability of a CPU to execute multiple threads concurrently.
Python’s concurrency methods including
threading,
multiprocessing, and
asyncio.
The difference between the threading and multiprocessing is this: the
threading module uses threads, the
multiprocessing module uses processes.
The
threading is the package that provides API to create and manage threads.
With
multiprocessing, Python creates new processes using an API similar to the
threading module.
The
asyncio is a library to write concurrent code using the
async/await syntax.
The keyword
async indicates that our function is a coroutine meaning they choose when to pause and let others execute and run
coroutines multitask cooperatively.
The three fundamental advantages of
async and
await over
threads are:
- cooperative multitasking - you can reasonably have millions of concurrent tasks;
- using await makes visible where the schedule points;
- if a task doesn’t yield then it can accidentally block all other tasks from running;
- tasks can support cancellation.
The next source of code show us how can deal with the execution code in Python 3 using the threading and multiprocessing python packages.
The
timeit python package is used to benchmark the code write in the
code_to_test variable:
Let's test the multi-threading execution with python:
[mythcat@desk ~]$ python3
Python 3.7.6 (default, Jan 30 2020, 09:44:41)
[GCC 9.2.1 20190827 (Red Hat 9.2.1-1)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import timeit
>>> code_to_test = """
... import threading
...
... text = "Hello World"
...
... def print_text(text):
... for char in text:
... print (char)
...
... # multi-threading execution
... def multi_threads():
... thread_1 = threading.Thread(target=print_text(text))
... thread_2 = threading.Thread(target=print_text(text))
... thread_1.start()
... thread_2.start()
... thread_1.join()
... thread_2.join()
... multi_threads()
... """
>>>
>>> elapsed_time = timeit.timeit(code_to_test, number=1)
H
e
l
l
o
W
o
r
l
d
H
e
l
l
o
W
o
r
l
d
>>> print(elapsed_time)
0.010613240000566293
Let's test the serially execution with python:
[mythcat@desk ~]$ python3
Python 3.7.6 (default, Jan 30 2020, 09:44:41)
[GCC 9.2.1 20190827 (Red Hat 9.2.1-1)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import timeit
>>> code_to_test = """
... import threading
...
... text = "Hello World"
...
... def print_text(text):
... for char in text:
... print (char)
... # serially execution
... def serially():
... print_text(text)
... print_text(text)
... serially()
... """
>>> elapsed_time = timeit.timeit(code_to_test, number=1)
H
e
l
l
o
W
o
r
l
d
H
e
l
l
o
W
o
r
l
d
>>> print(elapsed_time)
0.011771811000471644
Let's test the multiprocessing execution with python:
[mythcat@desk ~]$ python3
Python 3.7.6 (default, Jan 30 2020, 09:44:41)
[GCC 9.2.1 20190827 (Red Hat 9.2.1-1)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import timeit
>>> code_to_test = """
... import multiprocessing
...
... text = "Hello World"
...
... def print_text(text):
... for char in text:
... print (char)
...
... # multiprocessing execution
... def multiprocessing_test():
... process_1 = multiprocessing.Process(target=print_text(text))
... process_2 = multiprocessing.Process(target=print_text(text))
... process_1.start()
... process_2.start()
... process_1.join()
... process_2.join()
... multiprocessing_test()
... """
>>> elapsed_time = timeit.timeit(code_to_test, number=1)
H
e
l
l
o
W
o
r
l
d
H
e
l
l
o
W
o
r
l
d
>>> print(elapsed_time)
0.3649730779998208
Since asyncio is a little complex, I will write about this in the next tutorial.
