`
kingj
  • 浏览: 425683 次
  • 性别: Icon_minigender_1
  • 来自: 成都
社区版块
存档分类
最新评论

Java多线程(二)、线程的生命周期和状态控制

 
阅读更多

 

本文转自csdn

Java多线程(二)、线程的生命周期和状态控制

 

分类: javaSE综合知识点 498人阅读 评论(0) 收藏 举报

 

一、线程的生命周期

 

线程状态转换图:

 

 

1、新建状态

 

用new关键字和Thread类或其子类建立一个线程对象后,该线程对象就处于新生状态。处于新生状态的线程有自己的内存空间,通过调用start方法进入就绪状态(runnable)。

 

注意:不能对已经启动的线程再次调用start()方法,否则会出现java.lang.IllegalThreadStateException异常。

 

2、就绪状态

 

处于就绪状态的线程已经具备了运行条件,但还没有分配到CPU,处于线 程就绪队列(尽管是采用队列形式,事实上,把它称为可运行池而不是可运行队列。因为cpu的调度不一定是按照先进先出的顺序来调度的),等待系统为其分配 CPU。等待状态并不是执行状态,当系统选定一个等待执行的Thread对象后,它就会从等待执行状态进入执行状态,系统挑选的动作称之为“cpu调 度”。一旦获得CPU,线程就进入运行状态并自动调用自己的run方法。

提示:如果希望子线程调用start()方法后立即执行,可以使用Thread.sleep()方式使主线程睡眠一伙儿,转去执行子线程。

3、运行状态

 

处于运行状态的线程最为复杂,它可以变为阻塞状态、就绪状态和死亡状态。

 

处于就绪状态的线程,如果获得了cpu的调度,就会从就绪状态变为运行状态,执行run()方法中的任务。如果该线程失去了cpu资源,就会又从运 行状态变为就绪状态。重新等待系统分配资源。也可以对在运行状态的线程调用yield()方法,它就会让出cpu资源,再次变为就绪状态。

 

 

 

当发生如下情况是,线程会从运行状态变为阻塞状态:

 

①、线程调用sleep方法主动放弃所占用的系统资源

 

②、线程调用一个阻塞式IO方法,在该方法返回之前,该线程被阻塞

 

③、线程试图获得一个同步监视器,但更改同步监视器正被其他线程所持有

 

④、线程在等待某个通知(notify)

 

⑤、程序调用了线程的suspend方法将线程挂起。不过该方法容易导致死锁,所以程序应该尽量避免使用该方法。

 

 

 

当线程的run()方法执行完,或者被强制性地终止,例如出现异常,或者调用了stop()、desyory()方法等等,就会从运行状态转变为死亡状态。

 

4、阻塞状态

 

处于运行状态的线程在某些情况下,如执行了sleep(睡眠)方法,或等待I/O设备等资源,将让出CPU并暂时停止自己的运行,进入阻塞状态。 

 

在阻塞状态的线程不能进入就绪队列。只有当引起阻塞的原因消除时,如睡眠时间已到,或等待的I/O设备空闲下来,线程便转入就绪状态,重新到就绪队列中排队等待,被系统选中后从原来停止的位置开始继续运行。有三种方法可以暂停Threads执行:

 

5、死亡状态

 

当线程的run()方法执行完,或者被强制性地终止,就认为它死去。这个线程对象也许是活的,但是,它已经不是一个单独执行的线程。线程一旦死亡, 就不能复生。 如果在一个死去的线程上调用start()方法,会抛出java.lang.IllegalThreadStateException异常。

 

 

 

二、线程状态的控制

 

Java提供了一些便捷的方法用于会线程状态的控制。 .

 

 void destroy()
          已过时。 该方法最初用于破坏该线程,但不作任何清除。它所保持的任何监视器都会保持锁定状态。不过,该方法决不会被实现。即使要实现,它也极有可能以suspend() 方式被死锁。如果目标线程被破坏时保持一个保护关键系统资源的锁,则任何线程在任何时候都无法再次访问该资源。如果另一个线程曾试图锁定该资源,则会出现死锁。这类死锁通常会证明它们自己是“冻结”的进程。有关更多信息,请参阅为何不赞成使用 Thread.stop、Thread.suspend 和 Thread.resume?
 void interrupt()
          中断线程。
 void join()
          等待该线程终止。
 void join(long millis)
          等待该线程终止的时间最长为 millis 毫秒。
 void join(long millis, int nanos)
          等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。
 void resume()
          已过时。 该方法只与 suspend() 一起使用,但 suspend() 已经遭到反对,因为它具有死锁倾向。有关更多信息,请参阅为何不赞成使用 Thread.stop、Thread.suspend 和 Thread.resume?
 void setDaemon(boolean on)
          将该线程标记为守护线程或用户线程。
 void setPriority(int newPriority)
          更改线程的优先级。
static void sleep(long millis)
          在指定的毫秒数内让当前正在执行的线程休眠(暂停执行),此操作受到系统计时器和调度程序精度和准确性的影响。
static void sleep(long millis, int nanos)
          在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠(暂停执行),此操作受到系统计时器和调度程序精度和准确性的影响。
 void start()
          使该线程开始执行;Java 虚拟机调用该线程的 run 方法。
 void stop()
          已过时。 该方法具有固有的不安全性。用 Thread.stop 来终止线程将释放它已经锁定的所有监视器(作为沿堆栈向上传播的未检查ThreadDeath 异常的一个自然后果)。如果以前受这些监视器保护的任何对象都处于一种不一致的状态,则损坏的对象将对其他线程可见,这有可能导致任意的行为。stop 的许多使用都应由只修改某些变量以指示目标线程应该停止运行的代码来取代。目标线程应定期检查该变量,并且如果该变量指示它要停止运行,则从其运行方法依次返回。如果目标线程等待很长时间(例如基于一个条件变量),则应使用interrupt 方法来中断该等待。有关更多信息,请参阅为何不赞成使用 Thread.stop、Thread.suspend 和 Thread.resume?
 void stop(Throwable obj)
          已过时。 该方法具有固有的不安全性。有关详细信息,请参阅 stop()。该方法的附加危险是它可用于生成目标线程未准备处理的异常(包括若没有该方法该线程不太可能抛出的已检查的异常)。有关更多信息,请参阅为何不赞成使用 Thread.stop、Thread.suspend 和 Thread.resume?
 void suspend()
          已过时。 该方法已经遭到反对,因为它具有固有的死锁倾向。如果目标线程挂起时在保护关键系统资源的监视器上保持有锁,则在目标线程重新开始以前任何线程都不能访问该资源。如果重新开始目标线程的线程想在调用resume 之前锁定该监视器,则会发生死锁。这类死锁通常会证明自己是“冻结”的进程。有关更多信息,请参阅为何不赞成使用 Thread.stop、Thread.suspend 和 Thread.resume?
static void yield()
          暂停当前正在执行的线程对象,并执行其他线程。

 

可以看到很多方法,已经标注为过时的,我们应该尽可能的避免使用它们,而应该重点关注start()、interrupt()、join()、sleep()、yield()等直接控制方法,和setDaemon()、setPriority()等间接控制方法。

 

 

 

1、线程睡眠——sleep

 

如果我们需要让当前正在执行的线程暂停一段时间,并进入阻塞状态,则可以通过调用Thread的sleep方法,从上面可以看到sleep方法有两种重载的形式,但是使用方法一样。

 

比如,我们想要使主线程每休眠100毫秒,然后再打印出数字:

 

  1. public class Test1 {  
  2.     public static void main(String[] args) throws InterruptedException {  
  3.         for(int i=0;i<100;i++){  
  4.             System.out.println("main"+i);  
  5.             Thread.sleep(100);  
  6.         }  
  7.     }  
  8. }  

可以明显看到打印的数字在时间上有些许的间隔。

注意如下几点问题

 

①、sleep是静态方法,最好不要用Thread的实例对象调用它,因为它睡眠的始终是当前正在运行的线程,而不是调用它的线程对象,它只对正在运行状态的线程对象有效。看下面的例子:

 

  1. public class Test1 {  
  2.     public static void main(String[] args) throws InterruptedException {  
  3.         System.out.println(Thread.currentThread().getName());  
  4.         MyThread myThread=new MyThread();  
  5.         myThread.start();  
  6.         myThread.sleep(1000);//这里sleep的就是main线程,而非myThread线程  
  7.         Thread.sleep(10);  
  8.         for(int i=0;i<100;i++){  
  9.             System.out.println("main"+i);  
  10.         }  
  11.     }  
  12. }  


②、Java线程调度是Java多线程的核心,只有良好的调度,才能充分发挥系统的性能,提高程序的执行效率。但是不管程序员怎么编写调度,只能最大限度 的影响线程执行的次序,而不能做到精准控制。因为使用sleep方法之后,线程是进入阻塞状态的,只有当睡眠的时间结束,才会重新进入到就绪状态,而就绪 状态进入到运行状态,是由系统控制的,我们不可能精准的去干涉它,所以如果调用Thread.sleep(1000)使得线程睡眠1秒,可能结果会大于1 秒。

  1. public class Test1 {  
  2.     public static void main(String[] args) throws InterruptedException {  
  3.         new MyThread().start();  
  4.         new MyThread().start();  
  5.     }  
  6. }  
  7.   
  8. class MyThread extends Thread {  
  9.     @Override  
  10.     public void run() {  
  11.         for (int i = 0; i < 3; i++) {  
  12.             System.out.println(this.getName()+"线程" + i + "次执行!");  
  13.             try {  
  14.                 Thread.sleep(50);  
  15.             } catch (InterruptedException e) {  
  16.                 e.printStackTrace();  
  17.             }  
  18.         }  
  19.     }  
  20. }  

看某一次的运行结果:

  1. Thread-0线程0次执行!  
  2. Thread-1线程0次执行!  
  3. Thread-1线程1次执行!  
  4. Thread-0线程1次执行!  
  5. Thread-0线程2次执行!  
  6. Thread-1线程2次执行!  

可以看到,线程0首先执行,然后线程1执行一次,又了执行一次。可以看到它并不是按照sleep的顺序执行的。

 

 

2、线程让步——yield

 

yield()方法和sleep()方法有点相似,它也是Thread类提供的一个静态的方法,它也可以让当前正在执行的线程暂停,让出cpu资源 给其他的线程。但是和sleep()方法不同的是,它不会进入到阻塞状态,而是进入到就绪状态。yield()方法只是让当前线程暂停一下,重新进入就绪 的线程池中,让系统的线程调度器重新调度器重新调度一次,完全可能出现这样的情况:当某个线程调用yield()方法之后,线程调度器又将其调度出来重新 进入到运行状态执行。

 

实际上,当某个线程调用了yield()方法暂停之后,优先级与当前线程相同,或者优先级比当前线程更高的就绪状态的线程更有可能获得执行的机会,当然,只是有可能,因为我们不可能精确的干涉cpu调度线程。

 

yield的用法:

 

  1. public class Test1 {  
  2.     public static void main(String[] args) throws InterruptedException {  
  3.         new MyThread("低级"1).start();  
  4.         new MyThread("中级"5).start();  
  5.         new MyThread("高级"10).start();  
  6.     }  
  7. }  
  8.   
  9. class MyThread extends Thread {  
  10.     public MyThread(String name, int pro) {  
  11.         super(name);// 设置线程的名称  
  12.         this.setPriority(pro);// 设置优先级  
  13.     }  
  14.   
  15.     @Override  
  16.     public void run() {  
  17.         for (int i = 0; i < 30; i++) {  
  18.             System.out.println(this.getName() + "线程第" + i + "次执行!");  
  19.             if (i % 5 == 0)  
  20.                 Thread.yield();  
  21.         }  
  22.     }  
  23. }  

关于sleep()方法和yield()方的区别如下:

①、sleep方法暂停当前线程后,会进入阻塞状态,只有当睡眠时间到了,才会转入就绪状态。而yield方法调用后 ,是直接进入就绪状态,所以有可能刚进入就绪状态,又被调度到运行状态。

 

②、sleep方法声明抛出了InterruptedException,所以调用sleep方法的时候要捕获该异常,或者显示声明抛出该异常。而yield方法则没有声明抛出任务异常。

 

③、sleep方法比yield方法有更好的可移植性,通常不要依靠yield方法来控制并发线程的执行。

 

 

 

3、线程合并——join

 

线程的合并的含义就是将几个并行线程的线程合并为一个单线程执行,应用场景是当一个线程必须等待另一个线程执行完毕才能执行时,Thread类提供了join方法来完成这个功能,注意,它不是静态方法。
从上面的方法的列表可以看到,它有3个重载的方法:
void join()    
    当前线程等该加入该线程后面,等待该线程终止。    
void join(long millis)    
    当前线程等待该线程终止的时间最长为 millis 毫秒。 如果在millis时间内,该线程没有执行完,那么当前线程进入就绪状态,重新等待cpu调度  
void join(long millis,int nanos)    
    等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。如果在millis时间内,该线程没有执行完,那么当前线程进入就绪状态,重新等待cpu调度  

例子:

  1. public class Test1 {  
  2.     public static void main(String[] args) throws InterruptedException {  
  3.         MyThread thread=new MyThread();  
  4.         thread.start();  
  5.         thread.join(1);//将主线程加入到子线程后面,不过如果子线程在1毫秒时间内没执行完,则主线程便不再等待它执行完,进入就绪状态,等待cpu调度  
  6.         for(int i=0;i<30;i++){  
  7.             System.out.println(Thread.currentThread().getName() + "线程第" + i + "次执行!");  
  8.         }  
  9.     }  
  10. }  
  11.   
  12. class MyThread extends Thread {  
  13.     @Override  
  14.     public void run() {  
  15.         for (int i = 0; i < 1000; i++) {  
  16.             System.out.println(this.getName() + "线程第" + i + "次执行!");  
  17.         }  
  18.     }  
  19. }  


在这个例子中,在主线程中调用thread.join(); 就是将主线程加入到thread子线程后面等待执行。不过有时间限制,为1毫秒。

 

 


4、线程的优先级

 

每个线程执行时都有一个优先级的属性,优先级高的线程可以获得较多的执行机会,而优先级低的线程则获得较少的执行机会。与线程休眠类似,线程的优先级仍然无法保障线程的执行次序。只不过,优先级高的线程获取CPU资源的概率较大,优先级低的也并非没机会执行。

 

每个线程默认的优先级都与创建它的父线程具有相同的优先级,在默认情况下,main线程具有普通优先级。

 

Thread类提供了setPriority(int newPriority)和getPriority()方法来设置和返回一个指定线程的优先级,其中setPriority方法的参数是一个整数,范围是1~·0之间,也可以使用Thread类提供的三个静态常量:

 

MAX_PRIORITY   =10

 

MIN_PRIORITY   =1

 

NORM_PRIORITY   =5

 

例子:

 

  1. public class Test1 {  
  2.     public static void main(String[] args) throws InterruptedException {  
  3.         new MyThread("高级"10).start();  
  4.         new MyThread("低级"1).start();  
  5.     }  
  6. }  
  7.   
  8. class MyThread extends Thread {  
  9.     public MyThread(String name,int pro) {  
  10.         super(name);//设置线程的名称  
  11.         setPriority(pro);//设置线程的优先级  
  12.     }  
  13.     @Override  
  14.     public void run() {  
  15.         for (int i = 0; i < 100; i++) {  
  16.             System.out.println(this.getName() + "线程第" + i + "次执行!");  
  17.         }  
  18.     }  
  19. }  

从结果可以看到 ,一般情况下,高级线程更显执行完毕。

注意一点:虽然Java提供了10个优先级别,但这些优先级别需要操作系统的支持。不同的操作系统的优先级并不相同,而且也不能很好的和Java的 10个优先级别对应。所以我们应该使用MAX_PRIORITY、MIN_PRIORITY和NORM_PRIORITY三个静态常量来设定优先级,这样 才能保证程序最好的可移植性。

 

 

 

5、守护线程

 

守护线程与普通线程写法上基本么啥区别,调用线程对象的方法setDaemon(true),则可以将其设置为守护线程。

 

 

 

守护线程使用的情况较少,但并非无用,举例来说,JVM的垃圾回收、内存管理等线程都是守护线程。还有就是在做数据库应用时候,使用的数据库连接池,连接池本身也包含着很多后台线程,监控连接个数、超时时间、状态等等。

 

 

 

setDaemon方法的详细说明:
public final void setDaemon(boolean on)将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时,Java 虚拟机退出。    
该方法必须在启动线程前调用。 该方法首先调用该线程的 checkAccess 方法,且不带任何参数。这可能抛出 SecurityException(在当前线程中)。   
  参数:
    on - 如果为 true,则将该线程标记为守护线程。    
  抛出:    
    IllegalThreadStateException - 如果该线程处于活动状态。    
    SecurityException - 如果当前线程无法修改该线程。

  1. /** 
  2. * Java线程:线程的调度-守护线程 
  3. */  
  4. public class Test {  
  5.         public static void main(String[] args) {  
  6.                 Thread t1 = new MyCommon();  
  7.                 Thread t2 = new Thread(new MyDaemon());  
  8.                 t2.setDaemon(true);        //设置为守护线程  
  9.   
  10.                 t2.start();  
  11.                 t1.start();  
  12.         }  
  13. }  
  14.   
  15. class MyCommon extends Thread {  
  16.         public void run() {  
  17.                 for (int i = 0; i < 5; i++) {  
  18.                         System.out.println("线程1第" + i + "次执行!");  
  19.                         try {  
  20.                                 Thread.sleep(7);  
  21.                         } catch (InterruptedException e) {  
  22.                                 e.printStackTrace();  
  23.                         }  
  24.                 }  
  25.         }  
  26. }  
  27.   
  28. class MyDaemon implements Runnable {  
  29.         public void run() {  
  30.                 for (long i = 0; i < 9999999L; i++) {  
  31.                         System.out.println("后台线程第" + i + "次执行!");  
  32.                         try {  
  33.                                 Thread.sleep(7);  
  34.                         } catch (InterruptedException e) {  
  35.                                 e.printStackTrace();  
  36.                         }  
  37.                 }  
  38.         }  
  39. }  

执行结果:
  1. 后台线程第0次执行!  
  2. 线程10次执行!  
  3. 线程11次执行!  
  4. 后台线程第1次执行!  
  5. 后台线程第2次执行!  
  6. 线程12次执行!  
  7. 线程13次执行!  
  8. 后台线程第3次执行!  
  9. 线程14次执行!  
  10. 后台线程第4次执行!  
  11. 后台线程第5次执行!  
  12. 后台线程第6次执行!  
  13. 后台线程第7次执行!   

 

从上面的执行结果可以看出:前台线程是保证执行完毕的,后台线程还没有执行完毕就退出了。

 

 

 

实际上:JRE判断程序是否执行结束的标准是所有的前台执线程行完毕了,而不管后台线程的状态,因此,在使用后台县城时候一定要注意这个问题。

 

守护线程的用途:

 

守护线程通常用于执行一些后台作业,例如在你的应用程序运行时播放背景音乐,在文字编辑器里做自动语法检查、自动保存等功能。Java的垃圾回收也是一个守护线程。守护线

 

的好处就是你不需要关心它的结束问题。例如你在你的应用程序运行的时候希望播放背景音乐,如果将这个播放背景音乐的线程设定为非守护线程,那么在用户请求退出的时候,

 

不仅要退出主线程,还要通知播放背景音乐的线程退出;如果设定为守护线程则不需要了。

 

6、如何结束一个线程

 

Thread.stop()、Thread.suspend、Thread.resume、Runtime.runFinalizersOnExit这些终止线程运行的方法已经被废弃了,使用它们是极端不安全的!想要安全有效的结束一个线程,可以使用下面的方法。

 

1、正常执行完run方法,然后结束掉

 

2、控制循环条件和判断条件的标识符来结束掉线程

 

比如说run方法这样写:

 

  1. class MyThread extends Thread {  
  2.     int i=0;  
  3.     @Override  
  4.     public void run() {  
  5.         while (true) {  
  6.             if(i==10)  
  7.                 break;  
  8.             i++;  
  9.             System.out.println(i);  
  10.               
  11.         }  
  12.     }  
  13. }  

 

或者

 

  1. class MyThread extends Thread {  
  2.     int i=0;  
  3.     boolean next=true;  
  4.     @Override  
  5.     public void run() {  
  6.         while (next) {  
  7.             if(i==10)  
  8.                 next=false;  
  9.             i++;  
  10.             System.out.println(i);  
  11.         }  
  12.     }  
  13. }  


或者

  1. class MyThread extends Thread {  
  2.     int i=0;  
  3.     @Override  
  4.     public void run() {  
  5.         while (true) {  
  6.             if(i==10)  
  7.                 return;  
  8.             i++;  
  9.             System.out.println(i);  
  10.         }  
  11.     }  
  12. }  


只要保证在一定的情况下,run方法能够执行完毕即可。而不是while(true)的无线循环。

 

 

3、使用interrupt结束一个线程。

 

诚然,使用第2中方法的标识符来结束一个线程,是一个不错的方法,但是如果,该线程是处于sleep、wait、join的状态的时候,while循环就不会执行,那么我们的标识符就无用武之地了,当然也不能再通过它来结束处于这3种状态的线程了。

 

可以使用interrupt这个巧妙的方式结束掉这个线程。

 

我们看看sleep、wait、join方法的声明:

 

  1. public final void wait() throws InterruptedException  
  1. public static native void sleep(long millis) throws InterruptedException  
  1. public final void join() throws InterruptedException  

可以看到,这三者有一个共同点,都抛出了一个InterruptedException的异常。

在什么时候会产生这样一个异常呢?

每个Thread都有一个中断状状态,默认为false。可以通过Thread对象的isInterrupted()方法来判断该线程的中断状态。可以通过Thread对象的interrupt()方法将中断状态设置为true。

 

当一个线程处于sleep、wait、join这三种状态之一的时候,如果此时他的中断状态为true,那么它就会抛出一个InterruptedException的异常,并将中断状态重新设置为false。

 

看下面的简单的例子:

 

  1. public class Test1 {  
  2.     public static void main(String[] args) throws InterruptedException {  
  3.         MyThread thread=new MyThread();  
  4.         thread.start();  
  5.     }  
  6. }  
  7.   
  8. class MyThread extends Thread {  
  9.     int i=1;  
  10.     @Override  
  11.     public void run() {  
  12.         while (true) {  
  13.             System.out.println(i);  
  14.             System.out.println(this.isInterrupted());  
  15.             try {  
  16.                 System.out.println("我马上去sleep了");  
  17.                 Thread.sleep(2000);  
  18.                 this.interrupt();  
  19.             } catch (InterruptedException e) {  
  20.                 System.out.println("异常捕获了"+this.isInterrupted());  
  21.                 return;  
  22.             }  
  23.             i++;  
  24.         }  
  25.     }  
  26. }  

测试结果:

  1. 1  
  2. false  
  3. 我马上去sleep了  
  4. 2  
  5. true  
  6. 我马上去sleep了  
  7. 异常捕获了false  

可 以看到,首先执行第一次while循环,在第一次循环中,睡眠2秒,然后将中断状态设置为true。当进入到第二次循环的时候,中断状态就是第一次设置的 true,当它再次进入sleep的时候,马上就抛出了InterruptedException异常,然后被我们捕获了。然后中断状态又被重新自动设置 为false了(从最后一条输出可以看出来)。

 

 

所以,我们可以使用interrupt方法结束一个线程。具体使用如下:

 

  1. public class Test1 {  
  2.     public static void main(String[] args) throws InterruptedException {  
  3.         MyThread thread=new MyThread();  
  4.         thread.start();  
  5.         Thread.sleep(3000);  
  6.         thread.interrupt();  
  7.     }  
  8. }  
  9.   
  10. class MyThread extends Thread {  
  11.     int i=0;  
  12.     @Override  
  13.     public void run() {  
  14.         while (true) {  
  15.             System.out.println(i);  
  16.             try {  
  17.                 Thread.sleep(1000);  
  18.             } catch (InterruptedException e) {  
  19.                 System.out.println("中断异常被捕获了");  
  20.                 return;  
  21.             }  
  22.             i++;  
  23.         }  
  24.     }  
  25. }  

多测试几次,会发现一般有两种执行结果:

  1. 0  
  2. 1  
  3. 2  
  4. 中断异常被捕获了  

或者

  1. 0  
  2. 1  
  3. 2  
  4. 3  
  5. 中断异常被捕获了  

 

这两种结果恰恰说明了  只要一个线程的中断状态一旦为true,只要它进入sleep等状态,或者处于sleep状态,立马回抛出InterruptedException异常。

 

第一种情况,是当主线程从3秒睡眠状态醒来之后,调用了子线程的interrupt方法,此时子线程正处于sleep状态,立马抛出InterruptedException异常。

第一种情况,是当主线程从3秒睡眠状态醒来之后,调用了子线程的interrupt方法,此时子线程还没有处于sleep状态。然后再第3次while循环的时候,在此进入sleep状态,立马抛出InterruptedException异常。

分享到:
评论

相关推荐

    Java多线程-线程的生命周期

    线程生命周期的终点是死亡状态。线程在以下三种情况下结束:`run()`方法执行完毕、执行过程中抛出未捕获异常或错误,或者调用已过时的`stop()`方法。 6. 等待(Waiting): 从JDK1.5开始,线程可以进入等待状态,这...

    Java多线程知识点总结

    总之,掌握Java多线程的生命周期、创建、启动、同步以及线程池的使用是编写高效、稳定并发程序的基础。理解这些知识点对于解决并发编程中的问题,比如资源竞争、死锁、线程安全性等问题,至关重要。在实际开发中,...

    java线程生命周期详细讲解

    Java多线程生命周期的讲解,很详细,希望能帮到大家

    java多线程的讲解和实战

    Java多线程是Java编程中的重要概念,尤其在如今的多核处理器环境下,理解并熟练掌握多线程技术对于提高程序性能和响应速度至关重要。本资料详细讲解了Java多线程的原理,并提供了丰富的实战代码,非常适合Java初学者...

    4初学Java多线程:线程的生命周期.pdf

    在探讨Java多线程和线程生命周期时,我们首先应该明确,Java多线程是Java语言支持并发编程的一个重要特性,其允许同时执行多个任务,以提高程序的执行效率和改善用户体验。Java中的每个线程都有自己的生命周期,由一...

    JAVA多线程练习题答案。

    JAVA多线程练习题答案详解 在本文中,我们将对 JAVA 多线程练习题的答案进行详细的解释和分析。这些题目涵盖了 JAVA 多线程编程的基本概念和技术,包括线程的生命周期、线程同步、线程状态、线程优先级、线程安全等...

    Java多线程编程核心技术_完整版_java_

    Java多线程编程是Java开发中的重要组成部分,它允许程序同时执行多个任务,极大地提高了程序的效率和响应性。在Java中,多线程主要通过继承Thread类或实现Runnable接口来实现。本教程《Java多线程编程核心技术》将...

    汪文君JAVA多线程编程实战(完整不加密)

    书中详细介绍了Java多线程的核心概念,如线程的创建、启动、同步、协作以及生命周期管理。读者将学习如何通过实现Runnable接口或继承Thread类来创建线程,以及如何使用Executor框架来管理线程池。 此外,书中还深入...

    Java多线程机制(讲述java里面与多线程有关的函数)

    Java多线程机制是Java编程中至关重要的一部分,它允许程序同时执行多个任务,提升应用程序的效率和响应性。以下是对各个知识点的详细说明: 9.1 Java中的线程: Java程序中的线程是在操作系统级别的线程基础上进行...

    JAVA多线程编程技术PDF

    Java还提供了一些线程池的API,如ExecutorService和ThreadPoolExecutor,它们帮助管理线程生命周期,提高性能并减少资源消耗。通过设置线程池参数,可以定制线程的创建、复用和销毁策略,以适应不同场景的需求。 ...

    Java线程的生命周期和状态控制[定义].pdf

    Java线程的生命周期和状态控制是Java多线程编程中的核心概念。线程的状态转换是理解线程行为的关键,这包括新建状态、就绪状态、运行状态、阻塞状态和死亡状态。 1. 新建状态:当使用`new`关键字创建了一个`Thread`...

    java多线程课件

    总结来说,Java多线程技术是实现并发和优化程序性能的重要手段,理解线程的生命周期、创建方式、同步机制以及异常处理,是成为一名合格的Java开发者的必备技能。通过合理地设计和使用多线程,开发者可以构建出高效、...

    java 多线程编程实战指南(核心 + 设计模式 完整版)

    - **生命周期**:线程有新建、就绪、运行、阻塞和终止五种状态,理解这些状态转换对于管理线程至关重要。 - **同步机制**:包括`synchronized`关键字、`volatile`关键字、`Lock`接口及其子类,用于解决多线程环境...

    java 多线程示例

    Java多线程是Java编程中的重要概念,尤其在开发高性能、高并发的应用中不可或缺。本示例旨在为初学者提供一个全面理解Java多线程的起点。通过学习这个实例,你可以掌握如何创建和管理线程,理解线程同步与通信的重要...

    java多线程示例

    4. Executors框架:提供线程池服务,有助于管理和控制线程的生命周期。 六、线程优先级 Java中的线程优先级由Thread类的静态常量定义,如MIN_PRIORITY、NORM_PRIORITY和MAX_PRIORITY。但优先级并不保证绝对的执行...

    Java多线程编程

    7. **线程池**:`ExecutorService`是Java并发框架的核心,它允许开发者创建线程池,从而更好地管理和控制线程的生命周期。线程池可以通过`Executors`类的静态工厂方法创建,如`newFixedThreadPool`创建固定大小的...

    Java多线程编程实战指南-核心篇

    线程的生命周期包括新建、就绪、运行、阻塞和终止五个状态。 其次,书中会详细介绍线程同步机制。这是避免多线程环境下数据不一致的关键。Java提供了多种同步工具,如synchronized关键字、wait()和notify()方法、...

    初学Java多线程线程的生命周期.pdf

    初学Java多线程线程的生命周期.pdf

    java多线程.pdf

    本文将根据提供的文件信息,深入探讨Java多线程的相关概念和技术细节。 #### 二、Java线程基础 ##### 1. 什么是线程? 线程是进程中的最小执行单元,是进程内部的一次独立的控制流程。在Java中,每个进程至少有一...

Global site tag (gtag.js) - Google Analytics