Thread
Synchronization Related Problems
-
Deadlocks : Occurs when two threads wait for each other and
suspend indefinetly.
To a deadlock to occur each thread
must own a resource and wait for release of the other resource to advance. Which means neither of the threads relase its
resource and none of them continues its execution. To avoid deadlocks thread
execution shuould be designed in a such a way that threads obtain resources in
the same order. So that a situation that a thread waiting for release of other
resource never occurs.
-
Livelock: Happens when a thread acts in respond to act of
another thread and other thread acts similiarly, acts in respond to act ot
other thread. This way threads keeps busy each other preventing each other from
doing their actual work, thus producing
nothing.
-
Starvation: Happens when a thread with low priority has
never find a chance to obtain a specific resource because there are always
higher priority threads obtaining the required resource.
-
Thread
Interference: May occur
in the case that two threads are working on the same data. Consider following
example:
int a=7;
void commonMethod(){
a+=5;
}
Suppose Thread 1 and Thread 2 reads
the value of variable at the same time, obtaining value 7. Then each thread adds
5 to value of varible a and writes result
back to variable a. At the end value of variable a will be 12. However,
since two threads represent two seperate actions, result must have been 17. This
is a simple example of how lack of thread synchronization may cause incorrect
results.
-
Memory
Consistency Errors: In a multiprocesor environment each thread may
run on a different processer with its own local cahce. Memory consistency
errors occurs when a thread’s modifications on local chache are not visible to
other threads actually running on the same data.
int a=7;
void commonMethod(){
a+=5;
}
Consider the same example we used for
thread interference. This time suppose every thing goes fine. Thread 1 arrives
does the calculation and assigns value 12 to variable a. Then thread 2 comes
and finds out that value of variable a is 12 and does its part laeving result
of 17, what is really expected. However this is not a guaranteed case. Even
though threads arrives without interference, it is possible that each thread
has its own copy of variable a at thier local caches. In such a case, even thoug
thread 1 assigned value 12 to its copy of variable a, it won’t be visible to
thread 2. Thread 2 will still use variable a, actually its local copy of
variable a, with value 5.
Unfortunately there are more to Memory
Consistencey Errors. Consider following example:
int a=7;
boolean done=false;
void increment(){
a=+5;
done=true;
}
int get(){
if(done){
return a;
}
return -1;//indicating result
is not ready yet
}
Consider get and increment methods are
executed by seperate threads. Thread 1 increments a by 5 and sets done flag to
indicate operation is done. Thread 2 checks done flag and if it is true it will
be sure that result is ready, because first value of a is calculated and then
flag is set. Every thing looks perfect.
However in real world, it is not so
bright. Because compilers , under the name of optimization, may change the
order of instructions as they see fit, as long as semantics of the code remains
the same. As a result, it is possible that compiler changes order of a=+5 and done=true if it decides this way performance will be better.
Lets consider thread execution again. Thread 1 sets done flag first and before
it calculates value of a, thread 2 comes and checks and observes that done flag
is set and thinks value of variable a is ready. But actually it is not ready
yet. This is a totally undesired situation.
Conclusion: To deal with Memory Consistency Erros
and other syncronization related problems mentione above, shared resources must
be correctly synchronized.
Comments
Post a Comment