同步问题:高手请进！研究过Think in Java第14章多线程的请进

Question

下面是我对上面这一段内容的一些实践和遇到的问题：
....
看了一上午的Think in Java,觉得还是卓有成效的,应该立即写下来加深印象.我感觉我的大脑可重用性极低,总是需要生成新的记忆对象,从而耗费许多重复劳动.所以记下来,总结,精炼这样的工作应该多多益善.
要弄清synchronized的用法，首先要知道它是用来解决什么问题的.既然synchronized是同步的意思，那么它当然就是来解决不同步的问题的.下面就举一个不同步的例子来演示可能出现的问题.在这个例子当中,我们会创建两个线程类.一个叫TwoCounter,其工作是对两个计数器变量同时进行累加,从1开始,你马上会想道,我们是要用它来实现一个同步.另一个对象叫Watcher,顾名思义,是用来做监视工作的,它负责检查TwoCounter线程中的两个计数器的值是否相等,看起来这似乎是毫无意义的工作,因为既然是同步累加的,那么两个计数器的值怎么可能不相等呢??但,事实情况不是这样的.我们先来看程序.在看这个程序之前,最好先翻翻Think in Java的14.2.1，我的程序实际上是根据该节中给出的例子简化的,其中的主类改作了Sharing2class TwoCounter extends Thread {
  private int count1 = 0, count2 = 0;
  private boolean started=false;
  public void start(){
    if (!started) //防止多次对一个线程调用Start方法
    {
      started=true;
      super.start();
    }
  }
  public void run() {
    while (true) {
      count1++;
//如果TwoCounter运行到这个时候,CPU时间片被分配给了Watcher,那么这个时候Watcher读出来的两个计数器的值当然会不一样了，这个可能性是存在的。“这是由线程的本质造成的——它们可在任何时候挂起（暂停）。所以在上述两行的执行时刻之间，有时会出现执行暂停现象。同时，Watcher线程也正好跟随着进来，并正好在这个时候进行比较，造成计数器出现不相等的情况.”(Think in Java)
      count2++;
      System.out.println("Count1="+count1+",Count2="+count2);
      try {
        sleep(500);
      } catch (InterruptedException e){}
   }
  }  public void synchTest() {
    Sharing2.incrementAccess();
    if(count1 != count2)
            System.out.println("Unsynched");//一旦发现不同步,立即显示
  }
}class Watcher extends Thread {
  private Sharing2 p;
  public Watcher(Sharing2 p) { 
    this.p = p;
    start();
  }
  public void run() {
    while(true) {
      p.s.synchTest();
      try {
        sleep(500);
      } catch (InterruptedException e){}
    }
  }
}public class Sharing2 {
  TwoCounter s;
  private static int accessCount = 0;
  public static void incrementAccess() {
    accessCount++;
    System.out.println("accessCount="+accessCount);
  }
  public static void main(String[] args) {
    Sharing2 aaa = new Sharing2();
    aaa.s=new TwoCounter();
    aaa.s.start();//打开TwoCounter线程
    new Watcher(aaa);//打开Watcher线程
  }
} 上面的注释讲得很清楚了,有可能出现不同步的情况.但奇怪的是,我在运行的时候,却始终没有遇到不同步的情况,那么只有一种情况,就是程序中count1++和count2++几乎是同时进行的,watcher线程插不进来,但是为什么Think in Java上面的程序运行之后就肯定有不同步的情况呢?两个程序的原理是完全一样的,唯一不同的是我的程序较为简单,并且在命令行下运行,未使用GUI.难道是因为使用Applet方式运行或者以Windows主窗口的方式运行开销更大，使得watcher有机可趁吗?于是我试着在count1++和count2++之间加了一条循环语句,人为的增大空隙,目的是为了让watcher好插进来,造成监测出来的count1不等于count2的情况,实现不同步.修改后的程序是这样的
      ......
      count1++;
      for(int i=0;i<5000;i++);
      count2++;
      ......OK!再运行程序，很快就有不同步现象产生了,这似乎证明我刚才的分析是正确的.但奇怪的是,输出了一次Unsynchrized之后,以后就再也没有出现了,也就是说,watcher线程只有一次检测到了两个计数器count不同.这让我觉得有点郁闷,是巧合还是必然呢?也许是时间太短了,等下去肯定还会有Unsynchrized输出的.好了，我想问的，就是上面的这两段关于为什么程序简化了之后我看不到不同步的分析对不对，或者你们能够有什么新的见解。本人初学，谢谢各位指教。

Answer 1

to bluesmile979(笑着) 
我也曾经想到过是否因为线程太少而导致,但是我将Think in java的例程中的两个参数都设为1来运行,那么最后也就和我写的程序一样,只有两个线程，结果照样有不同步.这又怎么解释呢

Answer 2

线程的安排毕竟是随机的，很少会有不同步的出现,次数少了不容易发现。
我常用的方法是，先让无限循环开始，循环的时候也不要求输出什么的，只加上一个停止的条件，比如:
if (counter1 != counter2)
{
   System.out.println(counter1 + " ," + counter2)
   System.exit(0);
}
剩下的就是等了，一般十几秒甚至几秒就出结果了，可以发现记数已经到几十万或者几百万了。
如果同时开了5个线程，等了一分钟，我就算是它同步了。我的方法可能不太科学，不过效果挺好。

Answer 3

可以帮我调试一下吗？为什么我按照你的方法却始终没有得到结果呢？将下面的代码直接拷贝就可以了，程序名为Sharing2.java，版本是1.4.1class TwoCounter extends Thread {
  private int count1 = 0, count2 = 0;
  private boolean started=false;
  public void start(){
    if (!started) 
    {
      started=true;
      super.start();
    }
  }
  public void run() {
    while (true) {
      synchronized(this){
        count1++;
        count2++;
      }
//      System.out.println("Count1="+count1+",Count2="+count2);
      try {
        sleep(500);
      } catch (InterruptedException e){System.out.println("TwoCounter.run");}
   }
  }  public synchronized void synchTest() {
    Sharing2.incrementAccess();
    if(count1 != count2)
      {System.out.println(count1+","+count2);
       System.exit(0);
      }
  }
}class Watcher extends Thread {
  private Sharing2 p;
  public Watcher(Sharing2 p) { 
    this.p = p;
    start();
  }
  public void run() {
    while(true) {
      p.s.synchTest();
      try {
        sleep(500);
      } catch (InterruptedException e){System.out.println("Watcher.run");}
    }
  }
}public class Sharing2 {
  TwoCounter s;
  private static int accessCount = 0;
  public static void incrementAccess() {
//    accessCount++;
//    System.out.println("accessCount="+accessCount);
  }
  public static void main(String[] args) {
    Sharing2 aaa = new Sharing2();
    aaa.s=new TwoCounter();
    aaa.s.start();
    new Watcher(aaa);
  }
} ///:~

Answer 4

另外，根据你的意思，我的程序是没有问题的，只是线程少了，不同步很难产生，要等到counter增加到很大数目的时候才有可能，对吗？

Answer 5

对不起,刚才贴的代码错了,我把限制不同步的代码加进去了.原来的代码应该是这样的
class TwoCounter extends Thread {
  private int count1 = 0, count2 = 0;
  private boolean started=false;
  public void start(){
    if (!started) 
    {
      started=true;
      super.start();
    }
  }
  public void run() {
    while (true) {
        count1++;
        count2++;
//      System.out.println("Count1="+count1+",Count2="+count2);
      try {
        sleep(500);
      } catch (InterruptedException e){System.out.println("TwoCounter.run");}
   }
  }  public void synchTest() {
//    Sharing2.incrementAccess();
    if(count1 != count2)
      {System.out.println(count1+","+count2);
       System.exit(0);
      }
  }
}class Watcher extends Thread {
  private Sharing2 p;
  public Watcher(Sharing2 p) { 
    this.p = p;
    start();
  }
  public void run() {
    while(true) {
      p.s.synchTest();
      try {
        sleep(500);
      } catch (InterruptedException e){System.out.println("Watcher.run");}
    }
  }
}public class Sharing2 {
  TwoCounter s;
  private static int accessCount = 0;
  public static void incrementAccess() {
//    accessCount++;
//    System.out.println("accessCount="+accessCount);
  }
  public static void main(String[] args) {
    Sharing2 aaa = new Sharing2();
    aaa.s=new TwoCounter();
    aaa.s.start();
    new Watcher(aaa);
  }
} ///:~

Answer 6

我是这样想的：不同步而发生冲突是一种可能性，而sychronize是让这种可能性为0。你没有1发现不同步，并不能证明永远都不会发生不同步的情况，那只是一个时间问题。系统对线程的调度受了环境的影响，要是你机器上同时还跑了很多程序，可能情况就不同了。

Answer 7

呵呵，我用tianfeichen(侧耳倾听)的方法运行的程序，也就是我上面贴的代码居然有结果了,counter1= 217327，counter2=217356,还真想差的不少。但是时间上绝不是一两分钟那么简单,至少过了两个小时,可能真是我和他的运行环境的不同造成的.正如hey_you(Hey)所说,只是一个时间问题.希望其它人能给出更多的看法,如果觉得没必要再讨论下去,那我就接贴.

Answer 8

我考，一两个小时你也能坚持，服了。我认为问题结果也就两点了。一个就是我认为的线程数量另一个就是你认为的setText会有比较多的处理，占用比较多的资源。两种情况都会影响到这个问题的出现几率：）楼主宰总结一下吧，呵呵。

Answer 9

sleep（500）占用的时间胜过for（5000）的时间，因此线程在sleep中被切换的概率远胜于在for中被中断的概率！！事实上，两个变量从不相等变为相等，正是说明了不同步！！顺便说一下关于swing和awt控件在线程中操作时，比如setText，常造成很多意外
楼主可以看看相关的书籍！！

Answer 10

我将各位的观点综合起来总结一下:首先要肯定的是,假如不使用synchronized关键字来定义同步方法或者定义同步块,那么,发生不同步的可能是绝对存在的,反过来说,synchronized就是让这种可能性为0.在第一种情况下,发生不同步的可能虽然存在,但是它的几率受到以下几个方面因素的影响
1.在不同的操作系统及运行环境下,捕捉到不同步的几率可能就不一样,或者说等待的时间可能就有长有短
2.程序中线程数目的多寡,如果线程太少,那么这种不同步就难于捕捉到,可能需要等待很长的时间
3.代码本身的影响.比如使用awt类中涉及到GUI的方法，可能就会占用较多的资源,造成很多意外,那么发生冲突的可能性就大得多
4.线程是由操作系统随机分配的,本来就存在着不确定性,这种不确定性也会影响最后的结果不知道是否正确,大家还有什么补充呢?
明天正式结帖

Answer 11

不过说实话,我有点搞不懂,为什么最后的结果,counter1(217327)和counter2(217356)会相差那么多呢.按照我的程序,即便watcher线程插到两个自加的语句中间来，检测到的这两个计数器之间的差异顶多也就是1啊.出现这么大的差异,只可能是某一个计数器的自加语句有好多次在根本没有运行的情况下就被强行中断了.这就太恐怖了!虽然有其它线程的存在会干扰当前线程,但是也不至于让当前线程语句不运行吧,最多也就是等等再运行啊?我有点糊涂了,操作系统没学好,如果大家不嫌麻烦,清帮我解释一下吧