一道scjp的线程题

given:

public class TestThread {
    
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
      Runnable r=new Runnable(){
    	 public void run(){
    		 try{Thread.sleep(3000);}
    		 catch(InterruptedException e){ System.out.print("interrupted");}
    		 System.out.println("run");
    	 }
     };
     Thread t=new Thread(r);
     t.start();
     System.out.println("started");
     try{
     t.sleep(10000);
     }
     catch(InterruptedException e){ System.out.print("intered");}
     System.out.println("interruptting");
     t.interrupt();
     System.out.println("end");
     
	}

}

output：
started
run
interruptting
end
我的问题是为什么一定要按这个顺序输出呢？
Thread.sleep()是怎样工作的呢？run（）方法中调用try{Thread.sleep(3000);}说明t已经进入睡眠状态,可为什么main（）方法所在的线程也不继续工作了呢？
一定要等t线程醒过来并完成run（）方法main线程才能继续工作吗？
而且run（）方法结束后：输出"run"后，在main线程中怎么又调用t.sleep()了呢？这样可以吗？调用t.sleep(）方法后main线程又停住了？又要等t线程？
有点晕啊，高手帮忙看看！~

13 个解决方案

#1

没人答那，Thread.sleep（）怎么工作的啊~！

#2

线程对象t的sleep和run方法里的Thread.sleep是一个线程对象的睡眠。

#3

引用 2 楼 ma_liang 的回复:

线程对象t的sleep和run方法里的Thread.sleep是一个线程对象的睡眠。

我知道 两个线程睡眠不都是t线程睡眠吗？
的问题是为什么一定要按这个顺序输出呢？ 
run（）方法中调用try{Thread.sleep(3000);}说明t已经进入睡眠状态,
可为什么main（）方法所在的线程也不继续工作了呢？ 
一定要等t线程醒过来并完成run（）方法main线程才能继续工作吗？ 
而且run（）方法结束后：输出"run"后，在main线程中怎么又调用t.sleep()了呢？这样可以吗？
调用t.sleep(）方法后main线程又停住了？又要等t线程运行完毕？
t线程睡眠了，难道main线程就不能工作了吗？ 

#4

怎么美人答啊~是太简单了嘛！帮助一下啊！~~

#5

是的，你这个问题我也研究过，当线程程序顺序的执行到休眠的时候，后面就不在执行了，一直到休眠完成或者
被interrupt，才继续执行。

#6

引用 5 楼 zhangzuohai 的回复:

是的，你这个问题我也研究过，当线程程序顺序的执行到休眠的时候，后面就不在执行了，一直到休眠完成或者 
被interrupt，才继续执行。 

因为什么其他线程也不能执行了？

#7

我觉得应该是t线程睡眠了，但是mian线程仍然可以继续执行啊？为什么main线程也不执行了？

#8

class Name implements Runnable{
	public void run(){
		for(int x=1;x<3;x++){
			System.out.println("Run by"+Thread.currentThread().getName());
			try{
				Thread.sleep(5000);
			}
			catch(InterruptedException ex){

			}
			System.out.println(Thread.currentThread().getName()+"over");
		}
	}
}
public class ManyNames {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
      Name nr =new Name();
      Thread one =new Thread(nr);
      Thread two =new Thread(nr);
      Thread three =new Thread(nr);
      one.setName("1");
      two.setName("2");
      three.setName("3");
      one.start();
      two.start();
      three.start();
      System.out.println("main over");
	}

}

output：
Run by1
main over
Run by3
Run by2
2over
3over
1over
Run by2
Run by3
Run by1
1over
2over
3over
当然是随即的，不过这里
2over
3over
1over
确实同时输出的，也就是说线程“2”睡眠的同时“3”线程获得了cpu资源继续执行，然后也几乎是同时睡眠，进而“1”线程执行睡眠语句，也就是3个线程是同时睡眠的   而不是“2”先睡眠5秒，然后“3”睡眠5秒，然后“1”睡眠5秒。
不太明白1楼的例题是为什么！！

#9

我觉得1楼的例题是这样的：
1、启动了Runneble线程，这时会发生两种情况：
   1)系统启动了Runnable线程后又继续执行main线程，这时先输出started
   2)系统启动Runnable线程，并执行该线程，这时Runnable线程就睡了，所以系统就继续执行main线程，这时输出started
  综上，会先输出started
2、系统输出了started之后，会继续执行main线程，这时main线程又睡了，所以系统又会执行Runnable线程，这时输出run
3、Runnable线程输出完run之后该线程就结束了，于是继续执行main线程这时打印interruptting
4、t.interrupt();这句应该没有什么效果，因为调用到这句话的时候Runnable线程已经结束了
5、最后打印end

#10

引用 9 楼 painforever 的回复:

我觉得1楼的例题是这样的： 
1、启动了Runneble线程，这时会发生两种情况： 
  1)系统启动了Runnable线程后又继续执行main线程，这时先输出started 
  2)系统启动Runnable线程，并执行该线程，这时Runnable线程就睡了，所以系统就继续执行main线程，这时输出started 
  综上，会先输出started 
2、系统输出了started之后，会继续执行main线程，这时main线程又睡了，所以系统又会执行Runnable线程，这时输出run 
3、Runnabl…

也就是说

try{
     t.sleep(10000);
     }

是main线程睡了？不是t线程睡了？不是调用t线程的睡眠方法吗？怎么也是mian线程睡了？sleep（）的定义不是指定的毫秒数内让当前正在执行的线程休眠（暂停执行）。该线程不丢失任何监视器的所属权.在这题就是指当前的mian线程而不是调用其的线程t？

#11

恩，是main线程睡了，sleep()是静态方法，API上说：在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）。该线程不丢失任何监视器的所属权。 

#12

引用 11 楼 painforever 的回复:

恩，是main线程睡了，sleep()是静态方法，API上说：在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）。该线程不丢失任何监视器的所属权。 

感谢楼上的朋友 明白了。呵呵 API写清楚了其实 另外无论哪个线程睡眠，另外的线程会继续获得cpu的资源运行。

#13

受教了