新的java / android - 了解线程不一致的状态

Question

I was going through this tutorial and it mentioned that an "inconsistent state" will happen if we do not synchronize these 2 lines of code. I tried to reproduce this "inconsistent state" but I was not able to do so. Can you tell me exactly what is a "inconsistent state" ?

The tutorial stated, "the value of myColorInt won't match the value of myColorName".. but I did not seem to have any problem... can you explain what exactly is the problem they are trying to avoid?

Answer 1

The situation that is trying to be avoided is known as a race condition :

http://en.wikipedia.org/wiki/Race_condition

The result of the sequence

int myColorInt = color.getRGB();      //Statement 1
String myColorName = color.getName(); //Statement 2

depends on the timing with respect to this thread of code executing in other threads. If another thread sets the color in between these two statements, then the name stored in myColorName won't match the color stored in myColorInt . This is what the tutorial means by inconsistent state .

Synchronization is used to make certain guarantees about how mutable data is shared and accessible across threads. This block

synchronized (color) {
    int myColorInt = color.getRGB();
    String myColorName = color.getName();
} 

uses synchronization to make sure the two statements are executed atomically ; that is to say, to prevent another thread from changing the state of the color object while this thread is between the two statements (presuming that other threads are also using synchronization properly).

Concurrency and thread safety can be challenging to get correct, even for experts. Concurrency issues result in hard to diagnose, hard to reproduce, and sporadic problems. Since you're just starting out, I recommend avoiding concurrent programming for the time being if possible. Otherwise, the book Java Concurrency in Practice by Brian Goetz, et. al. is an excellent start.

Answer 2

Just because you don't see this problem doesn't mean it won't occur. However, it MIGHT occur and probably WILL occur at some point. This essentially means there is no guarantee about the outcome of these threads running, and without a guarantee you can't be sure what your code will do. Solution is to put it in a synchronized block

Answer 3

I suppose you mean this lines from the site you linked to, that could cause an "inconsistent state" if you omit the synchronization:

synchronized (color) {
    int myColorInt = color.getRGB();
    String myColorName = color.getName();
}

Please note that both methods getRGB() and getName() are declared as synchronized and that the set(…) method also contains a synchronized block.

---

Now imagine this scenario: Let us forget all this synchronized blocks, ie let us see what could happen, if they would not be there. We have two threads A and B.

Thread A wants to execute the following statements:

color.set(0, 0, 0, "Black");
int colorIntA = color.getRGB();
String colorNameA = color.getName();

Thread B wants to execute the same, but with the color white:

color.set(255, 255, 255, "White");
int colorIntB = color.getRGB();
String colorNameB = color.getName();

If all goes well, colorIntA is 0, colorNameA is "Black", colorIntB is 16777215 and colorNameB is "White".

Now let's say the scheduler decides to interrupt execution of thread A after executing getRGB() but before getName() . In the meantime all of threadB runs. So the whole execution looks like this:

color.set(0, 0, 0, "Black");
int colorIntA = color.getRGB();
// here thread A is interrupted and all of thread B runs
color.set(255, 255, 255, "White");
int colorIntB = color.getRGB();
String colorNameB = color.getName();
// thread B is done, continuing with remaining statement of thread A
String colorNameA = color.getName();

Now all is well with colorIntB and colorNameB but the variables of thread A are inconsistent: colorIntA is 0 (as expected) but colorNameA is "White"! This is the inconsistency the tutorial talks about.

Using the synchronized blocks avoids this so called race condition by not allowing thread B to work with color until thread A is done with it, ie thread B has to wait until the synchronized block from thread A is finished completely.

---

You might be able to see the problem in action when you put something like the following between getRGB() and getName() , which causes a random wait between 0 and 5 seconds:

try {
    Thread.sleep((long)(Math.random() * 5000));
} catch (InterruptedException e) {
    // not relevant in this case
}