[java thread safety] Object visibility across threads

Question

Hi,

I have a general doubt regarding publishing data and data changes across threads. Consider for example the following class.

public class DataRace {
  static int a = 0;

  public static void main() {
    new MyThread().start();
    a = 1;
  }

  public static class MyThread extends Thread {
    public void run() { 
      // Access a, b.
    }
  }
}

Lets focus on main().

Clearly

new MyThread().start();
a = 1;

There we change the shared variable a after the MyThread is started and thus may not be a thread-safe publication.

a = 1;
new MyThread().start();

However this time the change in a is safely published across the new thread, since Java Language Specification (JLS) guarantees that all variables that were visible to a thread A when it starts a thread B are visible to thread B, which is effectively like having an implicit synchronization in Thread.start().

new MyThread().start();
int b = 1;

In this case when a new variable is allocated after both the threads have been spawned, is there any guarantee that that the new variable will be safely published to all threads. i.e. if var b is accessed by the other thread, is it guaranteed to see its value as 1. Note that I'm not talking about any subsequent modifications to b after this (which certainly needs to be synchronized), but the first allocation done by the jvm.

Thanks,

Answer 1

a = 1;
new MyThread().start();

The assignment to 'a' will happen before start is called on the new thread, so the new thread will always print the value '1'

new MyThread().start();
a = 1;

In this case, MyThread can print 1 or 0 as the value of 'a'.

Answer 2

I wasn't not entirely sure about this one:

a = 1;
new MyThread().start();

... in that I wasn't sure there was any guarantee that the value of a would be "flushed" to shared memory before the new thread started. However, the spec explicitly talks about this. In section 17.4.4 it states:

An action that starts a thread synchronizes-with the first action in the thread it starts.

(The discussion after that basically shows that it'll be okay.)

I'm not sure what your last example (with b) is meant to be about.

Answer 3

MyThread().start() starts a new thread that runs seperately. The declaration of int b = 1 has nothing to do with the thread that you started. It continues in the main thread.

Thread safety is an issue if two threads read or mutate the same Object at the same time, or if two threads obtain locks on resources in reverse order, so that each one is waiting for the other one (this is called a deadlock).

Answer 4

I'm not sure what you're asking here. I think you're talking about thread-safe access to the "a" variable.

The issue is not the order of invocation but the fact that

-access to a is not threadsafe. So in an example with multiple threads updating and reading a, you won't ever be able to guarantee that the "a" you're reading is the same value as what you updated from (some other thread may have changed the value).

-in a multithreaded environment the jvm does not guarantee that the updated values for a are kept in sync. E.g.

Thread 1: a=1

Thread 2: a=2

Thread 1: print a <- may return 1

You can avoid this by declaring a "volatile".

As written there are no guarantees at all about the value of a.

BTW, Josh Bloch's Concurrency in Practice is a great book on this subject ( and I say that not having gotten all the way through it yet ;) - it really helped me to understand just how involved threading issues can get.

Answer 5

I have my doubts about this question :)

Issues regarding access to shared resources between concurrent threads of execution is a fairly well understood and investigated topic.

In general, if you have a source that is accessed with read/write semantics by a multiplicity of threads, you will need to regulate access to that resource. (Here the resource is the static int variable DataRace.a)

(I also +1 Steve B.'s note here that the issue here is not the order of invocations.)

Answer 6

If b is a local variable created within DataRace.main() as the code snippet indicates, it is not accessible to MyThread to begin with, so the question is moot.

If b is a shared variable between the main thread and the MyThread thread, it does not have the correct visibility in the absence of a proper memory barrier, so MyThread may not see the correct value promptly.