Thread Synchronization Related Problems

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.