j2se问题！

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 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 {
TT tt = new TT();
Thread t = new Thread(tt);
t.start();

tt.m2();

}
}
这是源码！
我的问题是：public synchronized void m1() throws Exception {
b = 1000;
Thread.sleep(5000);
System.out.println("b= "+b);
被锁住了
执行的是：
public void m2() throws Exception {
Thread.sleep(2500);
b = 2000;
}这个方法为什么输结果是b=      2000；public void m2() throws Exception {
Thread.sleep(2500);
b = 2000;
}这里面没有打印的语句啊！

Answer 1

public static void main(String [] args) throws Exception {
TT tt = new TT();
Thread t = new Thread(tt);
t.start();tt.m2();}
}
这里先执行m2,再执行m1()的可能性比较大。
[code=Java]
public synchronized void m1() throws Exception {
System.out.println("进入m1");
b = 1000;
Thread.sleep(5000);
System.out.println("b= " + b);
}
public void m2() throws Exception {
System.out.println("进入m2");
Thread.sleep(2500);
b = 2000;
}
t.start()执行后，m1()可允许，但是并不一定运行，这是m2和m1都有可能优先执行。
Java多线程是抢占式的。你可以在m1 m2前增加俩打印语句，看看谁先执行。[/code]

Answer 2

格式乱了！哈哈。我先说m1 m2都有可能先执行，m2执行的概率大。

Answer 3

子线程tt执行到m1()中的sleep(5000)被挂起,切换到主线程执行tt.m2(),b被赋值为2000，然后子线程System.out.println("b= "+b)打印的b是2000
哈哈  纯属个人理解~

Answer 4

这里是先执行m2方法，把b的值更改过了！根据Thread.sleep(）的时间就可以判定。synchronized  只是做上锁的功能因为m2先执行，所以synchronized对m2没有影响

Answer 5

b开始时时1000但执行sleep后被m2函数改为了2000接着输出了被改后的b

Answer 6

都是一个对象，所以同步不能解决，设置个标识位判断是否完成。
demopublic class TT implements Runnable {
int b = 100;
boolean isDone;
public synchronized void m1() throws Exception {
while(!isDone);
b = 1000;
Thread.sleep(5000);
System.out.println("b= " + b);
} public void m2() throws Exception {

Thread.sleep(2500);
b = 2000;
isDone = true;
} 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(); }
}
Good Luck.

Answer 7

package com.xuz.csdn.july11;public class TT implements Runnable {
int b = 100; public synchronized void m1() throws Exception {
System.out.println("m1");
b = 1000;
System.out.println("in m1 sleep before b = " + b);
Thread.sleep(5000);
System.out.println("in m1 sleep after b = " + b);
System.out.println("b= " + b);
} public void m2() throws Exception {
System.out.println("m2");
System.out.println("in m2 sleep before b = " + b);
Thread.sleep(2500);
b = 2000;
System.out.println("in m2 sleep after b = " + b);
} 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(); }
}
基本可以看出执行顺序了。

Answer 8

结果是由你设置的sleep的时间决定的。
当猪线程m2方法先执行的时候，休眠2.5秒。此刻线程进入m1方法，继续休眠5秒。
此刻，m2已经休眠完成，将b设置成2000。等到m1休眠完成后自然输出2000.
你可以把m1的sleep时间设置的短点，自然就出现不同的结果。

Answer 9

各位，你们回答的我都知道！ public void m2() throws Exception {
Thread.sleep(2500);
b= 2000;
}
这里面并没有：System.out.println("b= "+b);
但是，还是打印出来了，我想知道这里是用了面向对象的什么原理！

Answer 10

各位，你们回答的我都知道！ public void m2() throws Exception {
Thread.sleep(2500);
b= 2000;
}
这里面并没有：System.out.println("b= "+b);
但是，还是打印出来了，我想知道这里是用了面向对象的什么原理！ 
 

Answer 11

这个不管面向对象什么事吧。你的程序很明显，在m1执行了 b=1000的语句后陷入沉睡，此时b=1000.跟着执行m2，b被赋值成2000.m1方法在沉睡完成后，打印b的值，此时b是2000。结果完全正确。调用顺序：
main->m1->b=1000->m1 sleep->m2 sleep->m2 wake up->b=2000->m1 wake up->m1 print.需要注意的是，m2是在主线程中执行的，一般来说，主线程的优先级是要比子线程高的。不过，线程这个东西，一切皆有可能所以，最终输出结果为1000，也不是完全没有可能。

Answer 12

结果是由你设置的sleep的时间决定的。
当猪线程m2方法先执行的时候，休眠2.5秒。此刻线程进入m1方法，继续休眠5秒。
此刻，m2已经休眠完成，将b设置成2000。等到m1休眠完成后自然输出2000.
你可以把m1的sleep时间设置的短点，自然就出现不同的结果。