基本操作.docx

基本操作.docx

《基本操作.docx》由会员分享，可在线阅读，更多相关《基本操作.docx（19页珍藏版）》请在冰豆网上搜索。

基本操作

Java多线程

（二）、线程的生命周期和状态控制

分类：

 javaSE综合知识点2012-09-1016:

11 21749人阅读 评论（3） 收藏 举报

一、线程的生命周期

线程状态转换图：

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毫秒，然后再打印出数字：

[cpp] viewplaincopy

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的实例对象调用它，因为它睡眠的始终是当前正在运行的线程，而不是调用它的线程对象，它只对正在运行状态的线程对象有效。

看下面的例子：

[cpp] viewplaincopy

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秒。

[java] viewplaincopy

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.}  

看某一次的运行结果：

[java] viewplaincopy

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的用法：

[java] viewplaincopy

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调度 

例子：

[java] viewplaincopy

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（intnewPriority）和getPriority（）方法来设置和返回一个指定线程的优先级，其中setPriority方法的参数是一个整数，范围是1~·0之间，也可以使用Thread类提供的三个静态常量：

MAX_PRIORITY  =10

MIN_PRIORITY  =1

NORM_PRIORITY  =5

例子：

[java] viewplaincopy

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方法的详细说明：

publicfinalvoidsetDaemon（booleanon）将该线程标记为守护线程或用户线程。

当正在运行的线程都是守护线程时，Java虚拟机退出。

该方法必须在启动线程前调用。

该方法首先调用该线程的checkAccess方法，且不带任何参数。

这可能抛出SecurityException（在当前线程中）。

  参数：

    on-如果为true，则将该线程标记为守护线程。

  抛出：

    IllegalThreadStateException-如果该线程处于活动状态。

    SecurityException-如果当前线程无法修改该线程。

[java] viewplaincopy

1./** 

2.* Java线程：

线程的调度-守护线程 

3.*/  

4.public class Test {  

5.        public