下面的程序程序哪个方法体先执行?m1还是m2?高手分析一下好吗?进来看看

Question

下面的程序程序哪个方法体先执行?m1还是m2?高手分析一下好吗?进来看看
//加锁的举例
public class TT1 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(2500);
    b = 2000;  
  }
  
  public void run() {
    try {
       m1();
    } catch(Exception e)  {
      e.printStackTrace();
    }
  }
  
  public static void main(String[] args) throws Exception  {
    TT1 tt = new TT1();
    Thread t = new Thread(tt);
    t.start();    
   
    tt.m2();
    
    System.out.println(tt.b);
  }
  
}
 

Answer 1

public class TT1 implements Runnable { 
  int b = 100; 
  
  public synchronized void m1() throws Exception { 
      b = 1000;           (6)  
      Thread.sleep(5000);  (7)  // 这里程序阻塞 5000毫秒
      System.out.println("b = " + b);  (12)
  } 
    
  public synchronized void m2() throws Exception  { 
    Thread.sleep(2500);  (9)  // m2方法阻塞2500毫秒！
    b = 2000;  (10)  // 因为阻塞时间 2500<5000 所以 这个先自动释放，并执行
  } 
  
  public void run() {    (4) //程序走run 方法
    try { 
      m1();             (5)  // 调用m1()方法
    } catch(Exception e)  { 
      e.printStackTrace(); 
    } 
  } 
  
  public static void main(String[] args) throws Exception  { 
    TT1 tt = new TT1();   (1)
    Thread t = new Thread(tt);  (2) 
    t.start();    (3)  //启动线程
  
    tt.m2();  (8)   // 因为m1线程阻塞， main方法也是个线程，它继续执行，调用m2方法 
    
    System.out.println(tt.b);  (11)  
  } 
  
} 
 结果应该是：2000
b=1000

Answer 2

局部变量只存在于本方法中，在执行完m2()方法后，b 的值被释放了，所以b的值还是1000。

Answer 3

呵呵，运行了一下，结果是
1000 
b = 1000 但是，m2先执行，m1后执行。这里没有局部变量的问题，b是一个公共变量

Answer 4

public class TT1 implements Runnable { 
  int b = 100; 
  
  public synchronized void m1() throws Exception { 
      b = 1000;          (6)  
      Thread.sleep(5000);  (7)  // 这里程序阻塞 5000毫秒 
      System.out.println("b = " + b);  (12) 
  } 
    
  public synchronized void m2() throws Exception  { 
    Thread.sleep(2500);  (9)  // m2方法阻塞2500毫秒！ 
    b = 2000;  (10)  // 因为阻塞时间 2500 <5000 所以 这个先自动释放，并执行 
  } 
  
  public void run() {    (4) //程序走run 方法 
    try { 
      m1();            (5)  // 调用m1()方法 
    } catch(Exception e)  { 
      e.printStackTrace(); 
    } 
  } 
  
  public static void main(String[] args) throws Exception  { 
    TT1 tt = new TT1();  (1) 
    Thread t = new Thread(tt);  (2) 
    t.start();    (3)  //启动线程 
  
    tt.m2();  (8)  // 因为m1线程阻塞， main方法也是个线程，它继续执行，调用m2方法 
    
    System.out.println(tt.b);  (11)  
  } 
  
} 
思路很清晰

Answer 5

    t.start();    (3)  //启动线程 
  
    tt.m2();  (8)  // 因为m1线程阻塞， main方法也是个线程，它继续执行，调用m2方法关键是Thread的start方法并不是马上就执行，而是在系统有空闲时间时才会执行。所以tt.m2()会先执行，相当于同步方法，这时b=2000；之后锁接触，run方法被调用，在m1中b=1000；所以才会打印 1000
             b=1000

Answer 6

 我也是 copy 的楼主的代码运行的
为什么结果就不一样`
` 郁闷 `

Answer 7

楼上的几位，你们都错了！！
public class TT1 implements Runnable { 
  int b = 100; 
  
  public synchronized void m1() throws Exception { (6)//m2执行完毕，执行m1
      b = 1000;           //这个方法与这个程序的最后一句一起执行，哪个先执行不一定,所以输出的结果不确定。      Thread.sleep(5000);
      System.out.println("b = " + b);
  } 
    
  public synchronized void m2() throws Exception  { //(5)优先执行m2，此时tt被锁住，等m2执行完毕释放锁后tt的m1()才能执行。
    Thread.sleep(2500);
     b = 2000;
  } 
  
  public void run() {    (7) //程序走run 方法 
    try { 
      m1();            (8)  // 调用m1()方法 
    } catch(Exception e)  { 
      e.printStackTrace(); 
    } 
  } 
  
  public static void main(String[] args) throws Exception  { 
    TT1 tt = new TT1();  (1) 
    Thread t = new Thread(tt);  (2) 
    t.start();    (3)  //启动线程 
  
    tt.m2();  (4)  // 因为t不是主线程，所以它的启动可能需要一定的时间，所以这里会优先执行当前的这个主线程。 
    
    System.out.println(tt.b);  (6)  //这里的b不一定什么状态，可能是在m2里面刚赋值完毕，也可能已经在m1中赋值了。所以这个b的值不确定。  } 
  
} 大家看好，这个对象的方法是带锁的。所以请看仔细了再回答，以免误导别人。