k3xji wrote:
Quote:
Hi all,
>
This will probably be a long question/short answer, sorry, but I have
wandered net about the subject and really feel cannot find just enough
information.I want to ask my question by giving an example to
explicitly express my understanding which may be also wrong:
>
So, let's have a string in a module like:
st = 'IAmAstring'
When you make an assignment like that, python generates bytecode that
looks like this(straight from dis.dis):
1 0 LOAD_CONST 0 ('IAmAstring')
3 STORE_NAME 0 (a)
That's 1 instruction to load the constant and another one to bind it.
Quote:
My understanding: Python allocates a string object and binds the st to
that string's reference.
>
and let's have two threads simply doing following operations on the st
string:
>
Thread A:
st += 'ThreadAWasHere'
>
Thread B
st = 'ThreadBWasHere'
>
Let's think about the following situation:
Thread A reads the st value, and it is currently binded to an object
which is holding the string 'IAmAString'.
So let Thread B starts execution at that point. Note that Thread A
does not add the new string to object, it only reads st object. So,
then Thread B just writes to st, and all of a sudden st is binded to
something which is ThreadBWasHere. And then let's continue Thread A,
it already readed st's reference which is a reference to 'IamAString'.
>
So, finally if the execution flow is like above, we will have
'IAmAStringThreadAWasHere'. I am assuming this should not be the case.
We should have 'ThreadBWasHereThreadAWasHere' in the final string,
because we have just consumed the code in ThreadB.
>
Assuming that thread A and B contain nothing but that code, you will
either get 'ThreadBWasHereThreadAWasHere' or just 'ThreadBWasHere',
because by default the interpreter switches threads every 100 bytecode
instructions.
Quote:
Also, the other question is the operation st = 'ThreadBWasHere' is
atomic? I mean, if Python does not guarantee if an immutable object
assignment is atomic, then how can we say that the object is thread-
safe? So, if it is an atomic operation, which operators are atomic,
means only assignment'='? How about other operators like +=, or -
=..etc?
The augmented assignment operators first load the current value of the
variable like this:
a += 'asdf'
becomes
1 0 LOAD_NAME 0 (a)
3 LOAD_CONST 0 ('asdf')
6 INPLACE_ADD
7 STORE_NAME 0 (a)
Quote:
>
I am confused about which data structure to rely on thread-safety, or
operator in Python?
All of the builtin functions(which are implemented in C, like len()) are
atomic(but assigning their output to a value may not be).
I hope this helps,
AlcariTheMad
