j2se问题！

[codes23457789]

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;
}

这里面没有打印的语句啊！

[Headsen]

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]

[Headsen]

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

[a8141036]

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

[ruisheng_412]

这里是先执行m2方法，把b的值更改过了！

根据Thread.sleep(）的时间就可以判定。

synchronized 只是做上锁的功能

因为m2先执行，所以synchronized对m2没有影响

[shrekting777]

执行应该看cup的心情了！！

[happysmhzp]

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

[smileflyer]

都是一个对象，所以同步不能解决，设置个标识位判断是否完成。
demo

public 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.

[dr_lou]

如果先m2,后m1应该是1000啊。

[dr_lou]

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();

	}
}

基本可以看出执行顺序了。

[closewbq]

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

[codes23457789]

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

[codes23457789]

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

[chaosking]

这个不管面向对象什么事吧。

你的程序很明显，在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，也不是完全没有可能。

[xinlan1022]

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