What's Next
Tuesday, April 9, 2024
Useful Linux Commands
Wednesday, February 21, 2024
How to remove SNAP from ubuntu
Sunday, July 26, 2020
Thread Synchronization Mechanisms in Python
Fredrik Lundh | July 2007
This article discusses how to synchronize access to shared resources, and otherwise coordinate execution of threads.
One important issue when using threads is to avoid conflicts when more than one thread needs to access a single variable or other resource. If you’re not careful, overlapping accesses or modifications from multiple threads may cause all kinds of problems, and what’s worse, those problems have a tendency of appearing only under heavy load, or on your production servers, or on some faster hardware that’s only used by one of your customers.
For example, consider a program that does some kind of processing, and keeps track of how many items it has processed:
counter = 0 def process_item(item): global counter ... do something with item ... counter += 1
If you call this function from more than one thread, you’ll find that the counter isn’t necessarily accurate. It works in most cases, but sometimes misses one or more items. The reason for this is that the increment operation is actually executed in three steps; first, the interpreter fetches the current value of the counter, then it calculates the new value, and finally, it writes the new value back to the variable.
If another thread gets control after the current thread has fetched the variable, it may fetch the variable, increment it, and write it back, before the current thread does the same thing. And since they’re both seeing the same original value, only one item will be accounted for.
Another common problem is access to incomplete or inconsistent state, which can happen if one thread is initializing or updating some non-trivial data structure, and another thread attempts to read the structure while it’s being updated.
Atomic Operations #
The simplest way to synchronize access to shared variables or other resources is to rely on atomic operations in the interpreter. An atomic operation is an operation that is carried out in a single execution step, without any chance that another thread gets control.
In general, this approach only works if the shared resource consists of a single instance of a core data type, such as a string variable, a number, or a list or dictionary. Here are some thread-safe operations:
- reading or replacing a single instance attribute
- reading or replacing a single global variable
- fetching an item from a list
- modifying a list in place (e.g. adding an item using append)
- fetching an item from a dictionary
- modifying a dictionary in place (e.g. adding an item, or calling the clear method)
Note that as mentioned earlier, operations that read a variable or attribute, modifies it, and then writes it back are not thread-safe. Another thread may update the variable after it’s been read by the current thread, but before it’s been updated.
Also note that Python code may be executed when objects are destroyed, so even seemingly simple operations may cause other threads to run, and may thus cause conflicts. When in doubt, use explicit locks.
Locks #
Locks are the most fundamental synchronization mechanism provided by the threading module. At any time, a lock can be held by a single thread, or by no thread at all. If a thread attempts to hold a lock that’s already held by some other thread, execution of the first thread is halted until the lock is released.
Locks are typically used to synchronize access to a shared resource. For each shared resource, create a Lock object. When you need to access the resource, call acquire to hold the lock (this will wait for the lock to be released, if necessary), and call release to release it:
lock = Lock() lock.acquire() ... access shared resource lock.release()
For proper operation, it’s important to release the lock even if something goes wrong when accessing the resource. You can use try-finally for this purpose:
lock.acquire() try: ... access shared resource finally: lock.release()
In Python 2.5 and later, you can also use the with statement. When used with a lock, this statement automatically acquires the lock before entering the block, and releases it when leaving the block:
from __future__ import with_statement with lock: ... access shared resource
The acquire method takes an optional wait flag, which can be used to avoid blocking if the lock is held by someone else. If you pass in False, the method never blocks, but returns False if the lock was already held:
if not lock.acquire(False): ... failed to lock the resource else: try: ... access shared resource finally: lock.release()
You can use the locked method to check if the lock is held. Note that you cannot use this method to determine if a call to acquire would block or not; some other thread may have acquired the lock between the method call and the next statement.
if not lock.locked(): lock.acquire()
Problems with Simple Locking #
The standard lock object doesn’t care which thread is currently holding the lock; if the lock is held, any thread that attempts to acquire the lock will block, even if the same thread is already holding the lock. Consider the following example:
lock = threading.Lock() def get_first_part(): lock.acquire() try: ... fetch data for first part from shared object finally: lock.release() return data def get_second_part(): lock.acquire() try: ... fetch data for second part from shared object finally: lock.release() return data
Here, we have a shared resource, and two access functions that fetch different parts from the resource. The access functions both use locking to make sure that no other thread can modify the resource while we’re accessing it.
Now, if we want to add a third function that fetches both parts, we quickly get into trouble. The naive approach is to simply call the two functions, and return the combined result:
def get_both_parts(): first = get_first_part() second = get_second_part() return first, second
The problem here is that if some other thread modifies the resource between the two calls, we may end up with inconsistent data. The obvious solution to this is to grab the lock in this function as well:
def get_both_parts(): lock.acquire() try: first = get_first_part() second = get_second_part() finally: lock.release() return first, second
However, this won’t work; the individual access functions will get stuck, because the outer function already holds the lock. To work around this, you can add flags to the access functions that enables the outer function to disable locking, but this is error-prone, and can quickly get out of hand. Fortunately, the threading module contains a more practical lock implementation; re-entrant locks.
Re-Entrant Locks (RLock) #
The RLock class is a version of simple locking that only blocks if the lock is held by another thread. While simple locks will block if the same thread attempts to acquire the same lock twice, a re-entrant lock only blocks if another thread currently holds the lock. If the current thread is trying to acquire a lock that it’s already holding, execution continues as usual.
lock = threading.Lock() lock.acquire() lock.acquire() lock = threading.RLock() lock.acquire() lock.acquire()
The main use for this is nested access to shared resources, as illustrated by the example in the previous section. To fix the access methods in that example, just replace the simple lock with a re-entrant lock, and the nested calls will work just fine.
lock = threading.RLock() def get_first_part(): ... see above def get_second_part(): ... see above def get_both_parts(): ... see above
With this in place, you can fetch either the individual parts, or both parts at once, without getting stuck or getting inconsistent data.
Note that this lock keeps track of the recursion level, so you still need to call release once for each call to acquire.
Semaphores #
A semaphore is a more advanced lock mechanism. A semaphore has an internal counter rather than a lock flag, and it only blocks if more than a given number of threads have attempted to hold the semaphore. Depending on how the semaphore is initialized, this allows multiple threads to access the same code section simultaneously.
semaphore = threading.BoundedSemaphore() semaphore.acquire() ... access the shared resource semaphore.release()
The counter is decremented when the semaphore is acquired, and incremented when the semaphore is released. If the counter reaches zero when acquired, the acquiring thread will block. When the semaphore is incremented again, one of the blocking threads (if any) will run.
Semaphores are typically used to limit access to resource with limited capacity, such as a network connection or a database server. Just initialize the counter to the maximum number, and the semaphore implementation will take care of the rest.
max_connections = 10 semaphore = threading.BoundedSemaphore(max_connections)
If you don’t pass in a value, the counter is initialized to 1.
Python’s threading module provides two semaphore implementations; the Semaphore class provides an unlimited semaphore which allows you to call release any number of times to increment the counter. To avoid simple programming errors, it’s usually better to use the BoundedSemaphore class, which considers it to be an error to call release more often than you’ve called acquire.
Synchronization Between Threads #
Locks can also be used for synchronization between threads. The threading module contains several classes designed for this purpose.
Events #
An event is a simple synchronization object; the event represents an internal flag, and threads can wait for the flag to be set, or set or clear the flag themselves.
event = threading.Event() event.wait() event.set() event.clear()
If the flag is set, the wait method doesn’t do anything. If the flag is cleared, wait will block until it becomes set again. Any number of threads may wait for the same event.
Conditions #
A condition is a more advanced version of the event object. A condition represents some kind of state change in the application, and a thread can wait for a given condition, or signal that the condition has happened. Here’s a simple consumer/producer example. First, you need a condition object:
condition = threading.Condition()
The producing thread needs to acquire the condition before it can notify the consumers that a new item is available:
... generate item condition.acquire() ... add item to resource condition.notify() condition.release()
The consumers must acquire the condition (and thus the related lock), and can then attempt to fetch items from the resource:
condition.acquire() while True: ... get item from resource if item: break condition.wait() condition.release() ... process item
The wait method releases the lock, blocks the current thread until another thread calls notify or notifyAll on the same condition, and then reacquires the lock. If multiple threads are waiting, the notify method only wakes up one of the threads, while notifyAll always wakes them all up.
To avoid blocking in wait, you can pass in a timeout value, as a floating-point value in seconds. If given, the method will return after the given time, even if notify hasn’t been called. If you use a timeout, you must inspect the resource to see if something actually happened.
Note that the condition object is associated with a lock, and that lock must be held before you can access the condition. Likewise, the condition lock must be released when you’re done accessing the condition. In production code, you should use try-finally or with, as shown earlier.
To associate the condition with an existing lock, pass the lock to the Condition constructor. This is also useful if you want to use several conditions for a single resource:
lock = threading.RLock() condition_1 = threading.Condition(lock) condition_2 = threading.Condition(lock)
Thursday, June 18, 2020
Homebrew with Mac OS 10.15
after upgrading to High Sierra, uninstall brew & re-install with the below command to ensure the linking to the brew github and associated permissions to the local folder work correctly:
/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
Reference:
https://gist.github.com/irazasyed/7732946
Tuesday, June 9, 2020
Rsync with special PORT of target server
rsync -avz -e "ssh -p $portNumber" user@remoteip:/path/to/files/ /local/path/
Monday, March 23, 2020
How does asyncio work?
How does asyncio work?
https://stackoverflow.com/questions/49005651/how-does-asyncio-actually-work/51116910#51116910Before answering this question we need to understand a few base terms, skip these if you already know any of them.
Generators
Generators are objects that allow us to suspend the execution of a python function. User curated generators are implement using the keywordyield
. By creating a normal function containing the yield
keyword, we turn that function into a generator:>>> def test():
... yield 1
... yield 2
...
>>> gen = test()
>>> next(gen)
1
>>> next(gen)
2
>>> next(gen)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
As you can see, calling next()
on the generator causes the interpreter to load test's frame, and return the yield
ed value. Calling next()
again, cause the frame to load again into the interpreter stack, and continue on yield
ing another value.By the third time
next()
is called, our generator was finished, and StopIteration
was thrown.Communicating with a generator
A less-known feature of generators, is the fact that you can communicate with them using two methods:send()
and throw()
.>>> def test():
... val = yield 1
... print(val)
... yield 2
... yield 3
...
>>> gen = test()
>>> next(gen)
1
>>> gen.send("abc")
abc
2
>>> gen.throw(Exception())
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 4, in test
Exception
Upon calling gen.send()
, the value is passed as a return value from the yield
keyword.gen.throw()
on the other hand, allows throwing Exceptions inside generators, with the exception raised at the same spot yield
was called.Returning values from generators
Returning a value from a generator, results in the value being put inside theStopIteration
exception. We can later on recover the value from the exception and use it to our need.>>> def test():
... yield 1
... return "abc"
...
>>> gen = test()
>>> next(gen)
1
>>> try:
... next(gen)
... except StopIteration as exc:
... print(exc.value)
...
abc
Behold, a new keyword: yield from
Python 3.4 came with the addition of a new keyword: yield from
. What that keyword allows us to do, is pass on any next()
, send()
and throw()
into an inner-most nested generator. If the inner generator returns a value, it is also the return value of yield from
:>>> def inner():
... print('inner', (yield 2))
... return 3
...
>>> def outer():
... yield 1
... val = yield from inner()
... print('outer', val)
... yield 4
...
>>> gen = outer()
>>> next(gen)
1
>>> next(gen)
2
>>> gen.send("abc")
inner abc
outer 3
4
Putting it all together
Upon introducing the new keywordyield from
in Python
3.4, we were now able to create generators inside generators that just
like a tunnel, pass the data back and forth from the inner-most to the
outer-most generators. This has spawned a new meaning for generators - coroutines.Coroutines are functions that can be stopped and resumed while being run. In Python, they are defined using the
async def
keyword. Much like generators, they too use their own form of yield from
which is await
. Before async
and await
were introduced in Python 3.5, we created coroutines in the exact same way generators were created (with yield from
instead of await
).async def inner():
return 1
async def outer():
await inner()
Like every iterator or generator that implement the __iter__()
method, coroutines implement __await__()
which allows them to continue on every time await coro
is called.There's a nice sequence diagram inside the Python docs that you should check out.
In asyncio, apart from coroutine functions, we have 2 important objects: tasks and futures.
Futures
Futures are objects that have the__await__()
method implemented, and their job is to hold a certain state and result. The state can be one of the following:- PENDING - future does not have any result or exception set.
- CANCELLED - future was cancelled using
fut.cancel()
- FINISHED - future was finished, either by a result set using
fut.set_result()
or by an exception set usingfut.set_exception()
Another important feature of
future
objects, is that they contain a method called add_done_callback()
. This method allows functions to be called as soon as the task is done - whether it raised an exception or finished.Tasks
Task objects are special futures, which wrap around coroutines, and communicate with the inner-most and outer-most coroutines. Every time a coroutineawait
s a future, the future is passed all the way back to the task (just like in yield from
), and the task receives it.Next, the task binds itself to the future. It does so by calling
add_done_callback()
on the future. From now on, if the future will ever be done, by either
being cancelled, passed an exception or passed a Python object as a
result, the task's callback will be called, and it will rise back up to
existence.Asyncio
The final burning question we must answer is - how is the IO implemented?Deep inside asyncio, we have an event loop. An event loop of tasks. The event loop's job is to call tasks every time they are ready and coordinate all that effort into one single working machine.
The IO part of the event loop is built upon a single crucial function called
select
.
Select is a blocking function, implemented by the operating system
underneath, that allows waiting on sockets for incoming or outgoing
data. Upon data being received it wakes up, and returns the sockets
which received data, or the sockets whom are ready for writing.When you try to receive or send data over a socket through asyncio, what actually happens below is that the socket is first checked if it has any data that can be immediately read or sent. If it's
.send()
buffer is full, or the .recv()
buffer is empty, the socket is registered to the select
function (by simply adding it to one of the lists, rlist
for recv
and wlist
for send
) and the appropriate function await
s a newly created future
object, tied to that socket.When all available tasks are waiting for futures, the event loop calls
select
and waits. When the one of the sockets has incoming data, or it's send
buffer drained up, asyncio checks for the future object tied to that socket, and sets it to done.Now all the magic happens. The future is set to done, the task that added itself before with
add_done_callback()
rises up back to life, and calls .send()
on the coroutine which resumes the inner-most coroutine (because of the await
chain) and you read the newly received data from a nearby buffer it was spilled unto.Method chain again, in case of
recv()
:select.select
waits.- A ready socket, with data is returned.
- Data from the socket is moved into a buffer.
future.set_result()
is called.- Task that added itself with
add_done_callback()
is now woken up. - Task calls
.send()
on the coroutine which goes all the way into the inner-most coroutine and wakes it up. - Data is being read from the buffer and returned to our humble user.
yield from
capabilities that allow passing data back and forth from the inner-most
generator to the outer-most. It uses all of those in order to halt
function execution while it's waiting for IO to complete (by using the
OS select
function).And the best of all? While one function is paused, another may run and interleave with the delicate fabric, which is asyncio.
Thursday, May 16, 2019
python parallel processing
[2]https://wiki.python.org/moin/ParallelProcessing
very basic principle:
Pool doesn't support pickling shared data through its argument list. That's what the error message means by "objects should only be shared between processes through inheritance". The shared data needs to be inherited, i.e., global if you want to share it using the Pool class.
Pickle! Oh my GOD!
import multiprocessing
import ctypes
import numpy as np
shared_array_base = multiprocessing.Array(ctypes.c_double, 10*10)
shared_array = np.ctypeslib.as_array(shared_array_base.get_obj())
shared_array = shared_array.reshape(10, 10)
#-- edited 2015-05-01: the assert check below checks the wrong thing
# with recent versions of Numpy/multiprocessing. That no copy is made
# is indicated by the fact that the program prints the output shown below.
## No copy was made
##assert shared_array.base.base is shared_array_base.get_obj()
# Parallel processing
def my_func(i, def_param=shared_array):
shared_array[i,:] = i
if __name__ == '__main__':
pool = multiprocessing.Pool(processes=4)
pool.map(my_func, range(10))
print shared_array