请教大家一个问题

Question

public class TT implements Runnable {
int b = 100; public synchronized void m1() throws Exception {
b = 1000;
// Thread.sleep(5000);
System.out.println("b = " + b); } public synchronized void m2() throws Exception {
Thread.sleep(2000);
b = 2000; } public void run() {
try {
m1();
} catch (Exception e) {
e.printStackTrace();
}
} public static void main(String[] args) throws Exception { TT tt = new TT();
Thread t = new Thread(tt);
t.start();
tt.m2();
System.out.println(tt.b);
}
}请问该程序的执行过程，为什么该程序的输出结果有四个，即:2000 b=1000;b=1000 1000;1000 b=1000;b=1000 2000
最好是画个流程图给我，谢谢了

Answer 1

        TT tt = new TT();
        Thread t = new Thread(tt);
        t.start();//调用run里的m1
        tt.m2();//调用m2
        System.out.println(tt.b);//输出

Answer 2

楼主，这个题目的答案这样理解，有四种可能的运行结果，每运行一次只是可能有一种运行结果输出
第一种2000 b=1000
第二种b=1000 1000
第三种1000 b=1000
第四种b=1000 2000

Answer 3

我给你改一下代码，你看一下，能明白不：public class TT implements Runnable {
    int b = 100;    public synchronized void m1() throws Exception {
     System.out.println("m1 invoked");
        b = 1000;
        // Thread.sleep(5000);
        System.out.println("b = " + b);    }    public synchronized void m2() throws Exception {
     System.out.println("m2 invoked");
        Thread.sleep(2000);
        b = 2000;    }    public void run() {
        try {
            m1();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }    public static void main(String[] args) throws Exception {        TT tt = new TT();
        Thread t = new Thread(tt);
        t.start();
        tt.m2();
        System.out.println(tt.b);
    }
}

Answer 4

分析下这段程序，main一个线程，只是输出b的值，而另外加锁的两个线程共享一个对象的b值，分别是t.start()和tt.m2()这两者虽然写的是一前一后，但是在多线程环境下共同竞争CPU，二者都可能被先执行（概率性的）
同时在这两个线程执行过程中分别有5秒和2.5秒的休眠时间，在这个休眠时间内main主线程可能获取CPU资源，另外两个线程之前未获得CPU的一者也可能会获得CPU资源而执行（但也是不确定的）

Answer 5

tt.m2();   主线程
 Thread t = new Thread(tt);  t.start();  也是一个线程
所以是两个线程再跑
接下来分析四种出现的情况
（1）2000 b=1000
      主线程的m2方法先执行，因为方法都是同步的
       所以拿到执行m2方法时 该线程（主线程）拿到对象锁，其他线程等待
       b被赋值为2000
      System.out.println(tt.b);输出2000
      接下来t线程执行 m1方法于是输出 b=1000
（2）b=1000 1000
    这种就是上面当执行完m2方法b被赋值为2000后不是马上System.out.println(tt.b);
    而是先跑t线程执行b被赋值为1000  System.out.println("b = " + b);
    再主线程System.out.println(tt.b);
（3）1000 b=1000
     在程序执行好tt.m2();
    后线程t跑把b=1000时又停了，主线程输出1000后
   t线程再跑就输出b=1000
（4）b=1000 2000
    就是线程t先跑完 输出b=1000
    在执行t2方法是b=2000
   在最后输出2000注：同步方法只针对，不同线程调用同一对象的同步放才有用
    m1和m2都市同步方法  因为两个线程用的是同一个对象tt
   所以当一个线程在执行m1或m2方法时，另一个线程想执行m1或m2方法时必须等待先拿到锁的那个线程执行好
  第三种情况 是主线程执行好m2方法了 所以锁释放了，线程t开始跑执行m1方法
  至于跑到中间b=1000赋完值后停了  那是因为此时
主线程 System.out.println(tt.b);先执行了 这里没有调用对象tt的同步方法，所以主线程不会等待t把m1方法执行好再执行，可以随时插进来执行  

Answer 6

这段程序，有两个线程，一个是主线程，m1和m2是同步方法，当线程t启动时，是主线程继续拥有CPU时间片，还是线程t拥有CPU时间片，（也即问是m1()先执行还是m2()先执行？？？）

Answer 7

我觉得15楼已经讲的很详细了。。我是不想写这么多的很明显main()方法不是同步方法， m1,m2是同步方法

Answer 8

如果你想看
b=1000
1000的结果，这样改一下代码
   public static void main(String[] args) throws Exception {        TT tt = new TT();
        Thread t = new Thread(tt);
        t.start();
        tt.m2();
        Thread.currentThread().sleep(5000);
        System.out.println(tt.b);
    }
本来你的代码也可以出现这种情况，但不太明显