关于多线程共享变量的问题
public class Machine implements Runnable
{
   private int a=1;   //t1和t2是否共享这个a?
   public void run()
   {
      for(int i=0;i<20;i++)
      {
         a+=i;
         Thread.yield();
         a-=i;
         System.out.println(a);
      }
   }
   public static void main(String[] args) throws InterruptedException
   {
     Machine machine=new Machine();
     Thread t1=new Thread(machine);
     Thread t2=new Thread(machine);
     t1.start();
     t2.start();
    }
}

这个程序是从孙卫琴的书上照搬下来的？为什么我打印出来的a全部是1，而书却说a在递增呢？我用的是windowsXP系统
------解决方案--------------------
Windows

In the Hotspot implementation, the way that Thread.yield() works has changed between Java 5 and Java 6. 

In Java 5, Thread.yield() calls the Windows API call Sleep(0). This has the special effect of clearing the current thread's quantum and putting it to the end of the queue for its priority level. In other words, all runnable threads of the same priority (and those of greater priority) will get a chance to run before the yielded thread is next given CPU time. When it is eventually re-scheduled, it will come back with a full full quantum, but doesn't "carry over" any of the remaining quantum from the time of yielding. This behaviour is a little different from a non-zero sleep where the sleeping thread generally loses 1 quantum value (in effect, 1/3 of a 10 or 15ms tick). 

In Java 6, this behaviour was changed. The Hotspot VM now implements Thread.yield() using the Windows SwitchToThread() API call. This call makes the current thread give up its current timeslice, but not its entire quantum. This means that depending on the priorities of other threads, the yielding thread can be scheduled back in one interrupt period later. (See the section on thread scheduling for more information on timeslices.) 

Thread.yield();
这个就不是个靠谱的东西。不要考虑多线程先后顺序的问题，没准的。使用这个方法是为了让CPU有时间thread scheduling。这个可以解释为什么不同电脑打出来的不一样。
t1和t2是共享这个a，其他人已经解释清楚了。