1. 
   
2. 
   
3. 
   
4. class Demoo implements Runnable{
   
5.         public void run(){
   
6.                 for(int x=0;x<5;x++){
   
7.                         System.out.println(Thread.currentThread().toString()+">>线程与运行>>"+x);
   
8.                         Thread.yield();
   
9.                 }
   
10.         }
    
11. }
    
12. 
    
13. public class ThreadJoin {
    
14.         public static void main(String[] args) throws InterruptedException
    
15.         {
    
16.                 Demoo d = new Demoo();
    
17.                 Thread t1 = new Thread(d);
    
18.                 Thread t2 = new Thread(d);
    
19.                 t1.start();
    
20.                 try{
    
21.                         t1.sleep(5000);        //t1休息5秒        
    
22.                 }catch(InterruptedException e){
    
23.                         System.out.println(Thread.currentThread().getName()+"我被打断休息了");
    
24.                 }
    
25.                 t1.join();        
    
26.                 /*t1会申请加入到运行中来，抢夺执行权。
    
27.                  * 此时,main函数会将执行权交个t1，打断t1的休息时间，但是并没有抛出异常。为什么？
    
28.                  * 执行完毕后，会接着休息。但是是谁在休息？
    
29.                  */
    
30.                 t2.start();               
    
31.                 t2.join();
    
32.                 /*
    
33.                  * t2再次申请加入运行， 抢夺执行权，此时，main线程会将执行权交给
    
34.                  * t2.
    
35.                  */
    
36.                 for(int x=0;x<7;x++){
    
37.                         System.out.println(Thread.currentThread().getName()+">>>>run......"+x);
    
38.                 }
    
39.         }
    
40. }

复制代码

开启两个线程，总共3个，在t1.start()之后，t1.sleep(5000);然后t1.join();此时，t1加入的执行序列，打断了睡眠
，然后t1运行完，然后休息了一段时间，接着其他两个线程搞完。

问题：1，t1.join();时，打断了其休息，为什么没有报异常？？
2，t1搞完后，程序接着休息了几秒钟，此时，是谁在休息？？

t1.sleep(5000); 这里其实是在让main方法休息,因为sleep方法是让当前正在执行的线程(即他的上下文线程main)休息.

所以整体的执行流程是
t1开始执行
main线程休息5秒钟
5秒之内t1已经执行完所以接下来这句t1.jion()没有意义
然后t2开启
接着t2.join()阻塞主线程
最后组线程执行

另外不推荐用t1.sleep(5000)这种方式来阻塞线程,容易造成误解,理解为谁调用谁阻塞!!!!!!!!
规范的写法是Thread.sleep().要让那个线程休息,就在哪个线程内部调用此方法.

贾振凯 发表于 2013-4-2 23:32
t1.sleep(5000); 这里其实是在让main方法休息,因为sleep方法是让当前正在执行的线程(即他的上下文线程main) ...

搞定了。:victory:

如果问题未解决，请继续追问，如果没有问题了，请将帖子分类 改为“已解决”，谢谢

如果想中断另一个线程，只要持有那个线程的引用，调用interrupt（）就可以了
class MyRunable implements Runnable{
        @Override
        public void run() {
                // TODO Auto-generated method stub
                while(true){
                        try {
                                Thread.sleep(1000);
                        } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                }
        }
       
}
public class test {

        /**
         * @param args
         */
        public static void main(String[] args) {
                // TODO Auto-generated method stub
                MyRunable myRunnable = new MyRunable();
                Thread t = new Thread(myRunnable);
                t.start();
                t.interrupt();
        }

}

看得我一愣一愣的，搞了半天飞机。楼主 ，sleep 是个静态方法 ，不需要 对象调用， 容易引发误解。