CODEWITHSUNDEEP
javamultithreadingshared-memory
Amit
Amit

Reputation: 34763

Java Thread - Memory consistency errors

I was reading a Sun's tutorial on Concurrency.

But I couldn't understand exactly what memory consistency errors are? I googled about that but didn't find any helpful tutorial or article about that.

I know that this question is a subjective one, so you can provide me links to articles on the above topic.

It would be great if you explain it with a simple example.

Upvotes: 15

Views: 5683

Answers (5)

Alexander Pogrebnyak
Alexander Pogrebnyak

Reputation: 45586

Basically in absence of any synchronization threads can see a different value of a simple field. Consider this example:

class Foo
{
  int bar = 0;

  void unsafeCall ( )
  {
    final Foo thisObj = this;

    Runnable r = new Runnable ( )
    {
      public void run ( )
      {
        thisObj.bar = 1;
      }
    }

     Thread t = new Thread(r);

     t.start( );
     Thread.sleep( 1000 );

     // May print bar = 0
     System.out.println( "bar = " + bar );
  }
}

The simplest way of avoiding memory consistency error is to declare bar field to be volatile (see here for more details: https://www.ibm.com/developerworks/java/library/j-jtp06197/).

This forcing of threads to recheck the memory is called memory barrier. One other example of memory barrier is a synchronized method/block.

Upvotes: 4

William Bao
William Bao

Reputation: 298

I find a good example when searching this question. As below:

    Accesses to main memory might not occur in the same
    order that the CPU initiated them, particularly for writes
    (which often go through hardware write buffers so the CPU
    needn't wait for them). If CPU 1 writes the Answer to
    location A and then writes the AnswerIsReady flag to B,
    CPU 2 may see the change to B before it sees the change
    to A, and thus get the WrongAnswer. Making either or both
    writes atomic doesn't help; what's needed is something
    called a "memory barrier."

via http://www.velocityreviews.com/forums/t390825-memory-consistency-errors.html

Upvotes: 1

reprogrammer
reprogrammer

Reputation: 14718

If you'd like to get a deeper understanding of shared memory consistency models, I'd refer you to the following tutorial.

http://rsim.cs.uiuc.edu/~sadve/Publications/computer96.pdf

Upvotes: 0

Vincent Ramdhanie
Vincent Ramdhanie

Reputation: 103145

You can read up about Read After Write (RAW), Write after Write(WAW) and Write After Read (WAR) hazards to learn more about this topic. These hazards refer to pipelined processses but it really is the same problem that occurs with multi threading. It basically means that two different threads are updating the same location in memory and if you depend on these updates in a certain order then you may be surprised to see that you cannot guarantee the order in which the updates occur.

For example, if you have two statements:

  x = y + z;
  r = x + z;

in a single thread then you have no problem because the value of r will always be consistent. In multiple threads however, it is possible or either statement to occur first and the value of r is harder to predict.

Upvotes: 7

Enno Shioji
Enno Shioji

Reputation: 26882

Hm. They are basically talking about "visibility problems" and "re-ordering problems" (that terminology is more common at least in Java IMO). I think this link:http://www.cs.umd.edu/~pugh/java/memoryModel/jsr-133-faq.html#volatile explains what the tutorial is talking about, using more common terms (perhaps sun tried to use "easier" vocabulary or something).

Upvotes: 3

Related Questions