Java线程(四)：线程中断、线程让步、线程睡眠、线程合并

标签： java 线程 线程 | 发表时间：2014-06-02 23:18 | 作者：sunwengqin
出处：http://www.iteye.com

 最近在Review线程专栏，修改了诸多之前描述不够严谨的地方，凡是带有Review标记的文章都是修改过了。本篇文章是插进来的，因为原来没有写，现在来看传统线程描述的不太完整，所以就补上了。理解了线程同步和线程通信之后，再来看本文的知识点就会简单的多了，本文是做为传统线程知识点的一个补充。有人会问：JDK5之后有了更完善的处理多线程问题的类(并发包)，我们还需要去了解传统线程吗？答：需要。在实际开发中，无外乎两种情况，一个是开发新内容，另一个是维护原有程序。开发新内容可以使用新的技术手段，但是我们不能保证原有程序是用什么实现的，所以我们需要了解原有的。另外一点，了解传统线程的工作原理，使我们在使用并发包时更加得心应手。

 

线程中断

 
       线程中断涉及到三个方法，如下：
void interrupt()
          中断线程。
static boolean interrupted()
          测试当前线程是否已经中断。
boolean isInterrupted()
          测试线程是否已经中断。

       interrupt()方法用于中断线程，通常的理解来看，只要某个线程启动后，调用了该方法，则该线程不能继续执行了，来看个小例子：

[java]  view plain copy
 
  1. public class InterruptTest {  
  2.     public static void main(String[] args) throws InterruptedException {  
  3.         MyThread t = new MyThread("MyThread");  
  4.         t.start();  
  5.         Thread.sleep(100);// 睡眠100毫秒  
  6.         t.interrupt();// 中断t线程  
  7.     }  
  8. }  
  9. class MyThread extends Thread {  
  10.     int i = 0;  
  11.     public MyThread(String name) {  
  12.         super(name);  
  13.     }  
  14.     public void run() {  
  15.         while(true) {// 死循环，等待被中断  
  16.             System.out.println(getName() + getId() + "执行了" + ++i + "次");  
  17.         }  
  18.     }  
  19. }  

       运行后，我们发现，线程t一直在执行，没有被中断，原来interrupt()是骗人的，汗！其实interrupt()方法并不是中断线程的执行，而是为调用该方法的线程对象打上一个标记，设置其中断状态为true，通过isInterrupted()方法可以得到这个线程状态，我们将上面的程序做一个小改动：

[java]  view plain copy
 
  1. public class InterruptTest {  
  2.     public static void main(String[] args) throws InterruptedException {  
  3.         MyThread t = new MyThread("MyThread");  
  4.         t.start();  
  5.         Thread.sleep(100);// 睡眠100毫秒  
  6.         t.interrupt();// 中断t线程  
  7.     }  
  8. }  
  9. class MyThread extends Thread {  
  10.     int i = 0;  
  11.     public MyThread(String name) {  
  12.         super(name);  
  13.     }  
  14.     public void run() {  
  15.         while(!isInterrupted()) {// 当前线程没有被中断，则执行  
  16.             System.out.println(getName() + getId() + "执行了" + ++i + "次");  
  17.         }  
  18.     }  
  19. }  

       这样的话，线程被顺利的中断执行了。很多人实现一个线程类时，都会再加一个flag标记，以便控制线程停止执行，其实完全没必要，通过线程自身的中断状态，就可以完美实现该功能。如果线程在调用 Object 类的 wait()、wait(long) 或 wait(long, int) 方法，或者该类的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int) 方法过程中受阻，则其中断状态将被清除，它还将收到一个 InterruptedException。 我们可以捕获该异常，并且做一些处理。另外，Thread.interrupted()方法是一个静态方法，它是判断当前线程的中断状态，需要注意的是，线程的中断状态会由该方法清除。换句话说，如果连续两次调用该方法，则第二次调用将返回 false（在第一次调用已清除了其中断状态之后，且第二次调用检验完中断状态前，当前线程再次中断的情况除外）。

 

线程让步

 
       线程让步，其方法如下：
static void yield()
          暂停当前正在执行的线程对象，并执行其他线程

       线程让步用于正在执行的线程，在某些情况下让出CPU资源，让给其它线程执行，来看一个小例子：

[java]  view plain copy
 
  1. public class YieldTest {  
  2.     public static void main(String[] args) throws InterruptedException {  
  3.         // 创建线程对象  
  4.         YieldThread t1 = new YieldThread("t1");  
  5.         YieldThread t2 = new YieldThread("t2");  
  6.         // 启动线程  
  7.         t1.start();  
  8.         t2.start();  
  9.         // 主线程休眠100毫秒  
  10.         Thread.sleep(100);  
  11.         // 终止线程  
  12.         t1.interrupt();  
  13.         t2.interrupt();  
  14.     }  
  15. }  
  16. class YieldThread extends Thread {  
  17.     int i = 0;  
  18.     public YieldThread(String name) {  
  19.         super(name);  
  20.     }  
  21.     public void run() {  
  22.         while(!isInterrupted()) {  
  23.             System.out.println(getName() + "执行了" + ++i + "次");  
  24.             if(i % 10 == 0) {// 当i能对10整除时，则让步  
  25.                 Thread.yield();  
  26.             }  
  27.         }  
  28.     }  
  29. }  

       输出结果略，从输出结果可以看到，当某个线程(t1或者t2)执行到10次、20次、30次等时，就会马上切换到另一个线程执行，接下来再交替执行，如此往复。 注意，如果存在synchronized线程同步的话，线程让步不会释放锁(监视器对象)。

 

线程睡眠

 
       线程睡眠涉及到两个方法，如下：
static void sleep(long millis)
          在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）。
static void sleep(long millis, int nanos)
          在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠（暂停执行）。

        线程睡眠的过程中，如果是在synchronized线程同步内，是持有锁(监视器对象)的，也就是说，线程是关门睡觉的，别的线程进不来，来看一个小例子：

[java]  view plain copy
 
  1. public class SleepTest {  
  2.     public static void main(String[] args) {  
  3.         // 创建共享对象  
  4.         Service service = new Service();  
  5.         // 创建线程  
  6.         SleepThread t1 = new SleepThread("t1", service);  
  7.         SleepThread t2 = new SleepThread("t2", service);  
  8.         // 启动线程  
  9.         t1.start();  
  10.         t2.start();  
  11.     }  
  12.       
  13. }  
  14. class SleepThread extends Thread {  
  15.     private Service service;  
  16.     public SleepThread(String name, Service service) {  
  17.         super(name);  
  18.         this.service = service;  
  19.     }  
  20.     public void run() {  
  21.         service.calc();  
  22.     }  
  23. }  
  24. class Service {  
  25.     public synchronized void calc() {  
  26.         System.out.println(Thread.currentThread().getName() + "准备计算");  
  27.         System.out.println(Thread.currentThread().getName() + "感觉累了，开始睡觉");  
  28.         try {  
  29.             Thread.sleep(10000);// 睡10秒  
  30.         } catch (InterruptedException e) {  
  31.             return;  
  32.         }  
  33.         System.out.println(Thread.currentThread().getName() + "睡醒了，开始计算");  
  34.         System.out.println(Thread.currentThread().getName() + "计算完成");  
  35.     }  
  36. }  

       输出结果：

[java]  view plain copy
 
  1. t1准备计算  
  2. t1感觉累了，开始睡觉  
  3. t1睡醒了，开始计算  
  4. t1计算完成  
  5. t2准备计算  
  6. t2感觉累了，开始睡觉  
  7. t2睡醒了，开始计算  
  8. t2计算完成  
 

线程合并

 
       线程合并涉及到三个方法，如下：
 void join()
          等待该线程终止。
 void join(long millis)
          等待该线程终止的时间最长为  millis 毫秒。
 void join(long millis, int nanos)
          等待该线程终止的时间最长为  millis 毫秒 +  nanos 纳秒。
       线程合并是优先执行调用该方法的线程，再执行当前线程，来看一个小例子：
[java]  view plain copy
 
  1. public class JoinTest {  
  2.     public static void main(String[] args) throws InterruptedException {  
  3.         JoinThread t1 = new JoinThread("t1");  
  4.         JoinThread t2 = new JoinThread("t2");  
  5.         t1.start();  
  6.         t2.start();  
  7.         t1.join();  
  8.         t2.join();  
  9.         System.out.println("主线程开始执行！");  
  10.     }  
  11. }  
  12. class JoinThread extends Thread {  
  13.     public JoinThread(String name) {  
  14.         super(name);  
  15.     }  
  16.     public void run() {  
  17.         for(int i = 1; i <= 10; i++)  
  18.             System.out.println(getName() + getId() + "执行了" + i + "次");  
  19.     }  
  20. }  
       t1和t2都执行完才继续主线程的执行，所谓合并，就是等待其它线程执行完，再执行当前线程，执行起来的效果就好像把其它线程合并到当前线程执行一样。
 

线程优先级

 
       线程最低优先级为1，最高优先级为10，看起来就有10个级别，但这10个级别能不能和CPU对应上，还未可知，Thread类中提供了优先级的三个常量，如下： java.lang. Thread
public static final int MAX_PRIORITY 10
public static final int MIN_PRIORITY 1
public static final int NORM_PRIORITY 5
       我们创建线程对象后，如果不显示的设置优先级的话，默认为5。优先级可以看成一种特权，优先级高的，获取CPU调度的机会就大，优先级低的，获取CPU调度的机会就小，这个和我们现实生活很一样啊，优胜劣汰。线程优先级的示例就不写了，比较简单。
 

wait()和sleep()区别

 
       区别太大了，但是在Java线程面试题中是很常见的问题，相信你阅读过本专栏后，能够轻松的解答，这里不再赘述。
       原文地址： http://blog.csdn.net/ghsau/article/details/17560467，转载请注明


已有 0 人发表留言，猛击->> 这里<<-参与讨论


ITeye推荐



相关 [java 线程 线程] 推荐：

Java线程池

- - 企业架构 - ITeye博客
线程的使用在java中占有极其重要的地位，在jdk1.4极其之前的jdk版本中，关于线程池的使用是极其简陋的. 在jdk1.5之后这一情况有了很大的改观. Jdk1.5之后加入了java.util.concurrent包，这个包中主要介绍java中线程以及线程池的使用. 为我们在开发中处理线程的问题提供了非常大的帮助.

Java 线程池

- - 编程语言 - ITeye博客
在项目中，系统启动一个新线程的成本是比较高的，因为它涉及与操作系统交互. 在这种情形下，使用线程池可以很好地提高性能，尤其是当程序中需要创建大量生存周期很短的线程时，更应该考虑使用线程池. 使用线程池可以有效地控制系统中并发线程的数量，当系统中包含大量并发线程时，会导致系统性能剧烈下降，甚至导致JVM崩溃，而线程池的最大线程数参数可以控制系统中并发线程数不超过此数.

Java Thread多线程

- - CSDN博客推荐文章
Java Thread多线程. Java 多线程例子1 小例子. super("zhuyong");//设置线程的名字，默认为“TestThread”. Java 多线程例子2 前台线程（用户线程） 后台线程（守护线程 ）. 1，setDaemon（true）后就是后台线程（守护线程 ），反之就是前台线程（用户线程）.

Java线程之FutureTask

- - zzm
FutureTask是Future和Callable的结合体. 然后通过Future来取得计算结果. 但是，若开启了多个任务，我们无从知晓哪个任务最先结束，因此，若要实现“当某任务结束时，立刻做一些事情，例如记录日志”这一功能，就需要写一些额外的代码. FutureTask正是为此而存在，他有一个回调函数protected void done()，当任务结束时，该回调函数会被触发.

Java多线程之synchronized

- - CSDN博客推荐文章
这里通过三个测试类阐述了synchronized应用的不同场景. 首先是最基本的synchronized Method的使用.  * @see 概述：Java中的每个对象都有一个锁(lock)或者叫做监视器(monitor) .  * @see 说明：当synchronized关键字修饰一个方法时，则该方法为同步方法 .

java线程池分析

- - BlogJava-首页技术区
    在Java 5.0之前启动一个任务是通过调用Thread类的start()方法来实现的，任务的提于交和执行是同时进行的，如果你想对任务的执行进行调度或是控制 同时执行的线程数量就需要额外编写代码来完成. 5.0里提供了一个新的任务执行架构使你可以轻松地调度和控制任务的执行，并且可以建立一个类似数据库连接 池的线程池来执行任务.

java线程取消方式

- - 编程语言 - ITeye博客
JAVA任务取消方式一般有2种. 第一种设置某个取消标志，任务定期查看该标志，这种方式存在任务取消并不能保证任务立即取消，更糟糕的是有可能任务永远不会结束. 第二种是利用的中断机制，JVM并不能保证阻塞方法检测到中断的速度，但是实际中还是非常快的. 实例一（使用取消标志，会发现取消的任务还执行中，只有执行完再次检测标志任务才取消）.

Java线程池应用

- - CSDN博客架构设计推荐文章
1.减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务. 2.可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机). Java里面线程池的顶级接口是Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具.

Java线程池总结

- - Java - 编程语言 - ITeye博客
  假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间. 当T1 + T3 远大于 T2时，采用多线程技术可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力.     线程池就是一个线程的容器，每次只执行额定数量的线程， 线程池作用就是限制系统中执行线程的数量.

java多线程总结

- - Java - 编程语言 - ITeye博客
在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口. 对于直接继承Thread的类来说，代码大致框架是：. class 类名 extends Thread{. * @author Rollen-Holt 继承Thread类,直接调用run方法.             System.out.println(name + "运行     " + i);.