线程的sleep（）方法

 1 package XianChengFenXi;
 2 
 3 /*
 4  * 线程的sleep()方法
 5  *   static void sleep(Long millis)
 6  *   1.静态方法：Thread.sleep(1000)
 7  *   2.参数是毫秒
 8  *   3.作用是让当前线程进入休眠，即进入“阻塞状态”，放弃占有CPU时间片，让给其他线程使用。代码出现在A线程中，A线程就休眠，出现在B中，B就休眠
　　 *   4.Thread.sleep()方法可以用来：间隔特定的时间，去执行一段特定的代码，每隔多久执行一次
 9  */
10 public class ThreadTest6 {
11     
12     public static void main(String[] args){
13         //让当前线程进入休眠，睡眠5秒钟
14         //当前线程是主线程
15         try {
16             Thread.sleep(1000*5);
17         } catch (InterruptedException e) {
18             // TODO Auto-generated catch block
19             e.printStackTrace();
20         }
21         
22         //5秒后执行这里的代码
23         System.out.println("hello world!!!");
24     }
25 
26 }

 1 package XianChengFenXi;
 2 
 3 public class ThreadTest6 {
 4     
 5     public static void main(String[] args){
 6     
 7         for(int i=0;i<10;i++){
 8             System.out.println(Thread.currentThread().getName()+"---------"+i);
 9             try {
10                 Thread.sleep(1000);    //睡眠一秒钟
11             } catch (InterruptedException e) {
12                 // TODO Auto-generated catch block
13                 e.printStackTrace();
14             }
15         }
16     
17     
18     }
19     
20     
21 
22 }

 1 package XianChengFenXi;
 2 
 3 
 4 
 5 /*
 6  * 关于Thread.sleep()方法的面试题
 7  */
 8 public class ThreadTest7 {
 9     
10     public static void main(String[] args){
11         //创建线程对象
12         MyThread3 t=new MyThread3();
13         t.setName("t");
14         t.start();
15         
16         //调用sleep方法
17         try {
18             //问题：这行代码是否会让t线程进入休眠？
19             /*
20              不会，这个方法是个静态方法，与t没有关系，在执行的时候会转换成Thread.sleep(1000*5)，而这个方法是让当前线程进行休眠
21              而它在main里面，所以会让main线程进行休眠，而不是让分支线程进入休眠
22             */
23             t.sleep(1000*5);
24         } catch (InterruptedException e) {
25             // TODO Auto-generated catch block
26             e.printStackTrace();
27         }
28         
29         System.out.println("hello world!!");
30     }
31 
32 }
33 
34 class MyThread3 extends Thread{
35     public void run(){
36         for(int i=0;i<10000;i++){
37             System.out.println(Thread.currentThread().getName()+"------->"+i);
38         }
39     }
40 }

 1 package XianChengFenXi;
 2 
 3 
 4 /*
 5  * sleep睡眠太久，如果希望半路上醒来，该怎么办，即如何唤醒正在睡眠的线程？
 6  */
 7 
 8 public class ThreadTest8 {
 9     
10     public static void main(String[] args){
11         
12         Thread t=new Thread(new MyRunnable2());
13         t.setName("t");
14         t.start();
15         //希望5秒后，t线程醒来
16         try {
17             Thread.sleep(1000*5);
18         } catch (InterruptedException e) {
19             // TODO Auto-generated catch block
20             e.printStackTrace();
21         }
22         
23         //将t线程唤醒,这种中断睡眠的方式，依靠了java的异常处理方式，这里一执行，第39行代码即让线程睡眠一年的代码就会报异常，然后进入catch,接着整个try catch执行完毕
24         t.interrupt();
25     }
26 
27 }
28 
29 class MyRunnable2 implements Runnable{
30     public void run(){
31         System.out.println(Thread.currentThread().getName()+"-------->begin");
32         
33         /*
34          * 注：这里不能采用抛出异常，因为作为子类的MyRunnable2 不能抛出比父类更多的异常，即子类重写父类的方法，子类不能抛出比父类更宽泛的异常
35          *      所以run()方法中的异常不能throws只能try catch,因为run()方法在父类中没有抛出异常，而子类抛出的异常不能大于等于父类。
36          */
37         try {
38             //睡一年
39             Thread.sleep(1000*60*60*24*365);
40         } catch (InterruptedException e) {
41             // TODO Auto-generated catch block
42             e.printStackTrace();
43         }
44         
45         System.out.println(Thread.currentThread().getName()+"-------->end");
46     }
47 }