Java线程中代码顺序的问题

[doingendlessly]

做了一个线程方面的例子：
public class ThreadInterview implements Runnable{
int b = 10;

public synchronized void m1() throws Exception{
b = 3000;
Thread.sleep(2000);
System.out.println(Thread.currentThread().getName()+" b=" + b);
}

//public synchronized void m2() throws Exception{
public void m2() throws Exception{
b = 2000; //是这。将它标记为（一）
Thread.sleep(1000);
//b = 2000; //就是这。将它标记为（二）
}

public void run(){
try{
m1();
}catch(Exception e){
e.printStackTrace();
}
}

public static void main(String[] args) throws Exception {
ThreadInterview TI = new ThreadInterview();
Thread t = new Thread(TI);
t.start();

TI.m2();
System.out.println(Thread.currentThread().getName() + " b=" +TI.b);
}

}

以上代码中，如果使用标记（一）处的b=2000, 输出结果是：main b=3000
Thread-0 b=3000

如果使用标记（二）处的b=2000,输出结果是：main b=2000
Thread-0 b=2000

请问：这两处的位置有什么区别吗？为什么出现不一样的结果呢？ 还有，sleep()方法不就是休眠当前线程吗。

[lovecj6185]

线程什莫时候被执行是cpu说的算，这个诸葛亮来了也没用，呵呵
我们所谓设置的sleep，是指cpu执行这个线程的时候，到sleep这一句，让线程休眠
所以，不能说通过设置sleep的时间就能完全控制线程执行的顺序

[Miracle1216]

线程什么时候执行很难控制。

[yuwenbao]

呵呵，很有意思的问题，用楼主的程序测了几十遍，自以为有点心得如下：
线程启动是需要开销的，而再启动新的线程这段时间里，main线程已经运行到了TI.m2();
从而先调用了
b = 2000; //是这。将它标记为（一）
然后休眠
这时候新的线程启动，调用 b = 3000; 此时b已经变为了3000，然后main线程休眠
从而得到了楼主的结果

而//b = 2000; //就是这。将它标记为（二） 这里，main休眠，此时新的线程运行，
调用b=3000，然后休眠，然后main线程运行，b=2000被调用。此时，b就是2000

呵呵，为了证明以上的推测
改了下程序

public class TestThread implements Runnable {
    int b = 10;

    public synchronized void m1() throws Exception {
	b = 3000;
	Thread.sleep(2000);
	System.out.println(Thread.currentThread().getName() + " b=" + b);
    }

    // public synchronized void m2() throws Exception{
    public void m2() throws Exception {
	b = 2000; // 是这。将它标记为（一）
	Thread.sleep(1000);
	 //b = 2000; //就是这。将它标记为（二）
    }

    public void run() {
	try {
	    m1();
	} catch (Exception e) {
	    e.printStackTrace();
	}
    }

    public static void main(String[] args) throws Exception {
	TestThread TI = new TestThread();
	Thread t = new Thread(TI);
	t.start();

	for( int i = 0; i <10000; i++ )
	    ;
	
	TI.m2();
	System.out.println(Thread.currentThread().getName() + " b=" + TI.b);
    }

}

    

楼主可以这样运行下代码看看，就明白了

[yuwenbao]

所以线程池的出现是必要的

[彷徨的蜗牛]

如果你的是双核，双线程可能同步

[老张-AI]

[Quote=引用 3 楼 yuwenbao 的回复:]
呵呵，很有意思的问题，用楼主的程序测了几十遍，自以为有点心得如下：
线程启动是需要开销的，而再启动新的线程这段时间里，main线程已经运行到了TI.m2();
从而先调用了
b = 2000;    //是这。将它标记为（一）
然后休眠
这时候新的线程启动，调用 b = 3000; 此时b已经变为了3000，然后main线程休眠
从而得到了楼主的结果

而//b = 2000;  //就是这。将它标记为（二） 这里，main休眠，此时新的线程运行，
调用b=3000，然后休眠，然后main线程运行，b=2000被调用。此时，b就是2000

呵呵，为了证明以上的推测
改了下程序
Java codepublicclass TestThreadimplements Runnable {int b=10;publicsynchronizedvoid m1()throws Exception {
b=3000;
Thread.sleep(2000);
System.out.println(Thread.currentThread().getName()+" b="+ b);
}// public synchronized void m2() throws Exception{publicvoid m2()throws Exception {
b=2000;// 是这。将它标记为（一） Thread.sleep(1000);//b = 2000;//就是这。将它标记为（二） }publicvoid run() {try {
m1();
}catch (Exception e) {
e.printStackTrace();
}
}publicstaticvoid main(String[] args)throws Exception {
TestThread TI=new TestThread();
Thread t=new Thread(TI);
t.start();for(int i=0; i<10000; i++ )
;

TI.m2();
System.out.println(Thread.currentThread().getName()+" b="+ TI.b);
}

}
楼主可以这样运行下代码看看，就明白了
[/Quote]

学习了

[junyun414]

学习了。