Java中的volatile关键字对其他线程不可见，这是我的代码

Question

When I update the value of i in thread T1 , the value is not visible to thread T2 - why? Theoretically volatile variables must retrieve fresh values, but it is not working.

    class Threads implements Runnable
    {

      public volatile int i=4;
      volatile int j=0;
      int x=0;

      public static void main(String[] args) {
        Threads th=new Threads();
        Thread a = new Thread(th);
        Thread b=new Thread(th);
        a.setName("T1");
        a.setPriority(Thread.MAX_PRIORITY);
        b.setName("T2");
        a.start();
        b.start();
      }

      public int count() {
        return ++i;
      }

      public void run() {
        while(j<=10)
        {

          if(Thread.currentThread().getName().equals("T1"))
          {
            i++;
            System.out.println(Thread.currentThread().getName()+" : "+i);

           try
           {
             Thread.sleep(2);
           }catch(Exception ex){}
         }
         else if(Thread.currentThread().getName().equals("T2"))
         {

           System.out.println(Thread.currentThread().getName()+" : "+i);
           try
           {
             Thread.sleep(1);
           }catch(Exception ex){}
         }

         j++;
       }
      }
    }

Answer 1

I don't know what you expect your code to output, but:

Note that even if a variable is volatile, x++ is a shortcut for x = x + 1 . It is not atomic, and performs separate read and write operations, the value may be changed by another thread between the two operations.

In your case, for variable i , only one thread is writing the variable, so it should not be an issue.

But for j , two threads are doing j++ on the same variable. There is probability that, for some iterations, one thread writes j between the read and write of the other thread. Resulting in the earlier write to be ignored.

to avoid this, you can either:

• do the j++ in a synchronized block
• use AtomicInteger instead of volatile int

Another point is that the test on j <= 10 is done before the increment. So the two threads may enter the while for an iteration when j==10 , resulting in the end by having j==12 (or even something different when the effect described above is also involved).

To solve that, you may increment directly in the while condition, using an AtomicInteger for instance:

while(j.getAndIncrement() <= 10)

Answer 2

You are accessing the local i from each thread instance - each of your thread objects has their own i, j , x instances and you are not cross referencing them.

Actually your threads do not even know that there are any other threads out there.