文档章节

线程中断、线程让步、线程睡眠、线程合并(转载)

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

线程中断


       线程中断涉及到三个方法,如下:
void interrupt()
          中断线程。
static boolean interrupted()
          测试当前线程是否已经中断。
boolean isInterrupted()
          测试线程是否已经中断。
       interrupt()方法用于中断线程,通常的理解来看,只要某个线程启动后,调用了该方法,则该线程不能继续执行了,来看个小例子:
[java] 
  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]
  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] 
  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]
  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]
  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]
  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

我是IT码农
粉丝 6
博文 66
码字总数 29699
作品 0
成都
程序员
私信 提问
JAVA多线程--线程状态的转换

一、线程状态 线程状态总的可分为五大状态:分别是生、死、可运行、运行、等待/阻塞。 1、新状态:线程对象已经创建,还没有在其上调用start()方法。 2、可运行状态:当线程有资格运行,但调...

董家二少
2016/01/13
127
0
Java线程:线程状态的转换

一、线程状态 线程的状态转换是线程控制的基础。线程状态总的可分为五大状态:分别是生、死、可运行、运行、等待/阻塞。用一个图来描述如下: 1、新状态:线程对象已经创建,还没有在其上调用...

beibugulf
2016/11/18
16
0
Java 并发:第二部分 - 多线程

在了解了如何创建线程之后,我们将会在本篇文章中了解可以对多线程做什么。 当我们有了线程,我们就可以对线程做如下几個操作: 1、让当前线程在x毫秒的时间内睡眠; 2、等待壹個其它的线程结...

苗哥
2013/01/29
405
0
线程的生命周期和状态控制

一、线程的生命周期 线程状态转换图: 其中Thread.join()调用的是Object.wait()方法实现的,意思是让当前线程等待。是当前调用thread1.join()的线程等待,而不是让thread1这个线程等待。 1、...

小菜鸡1
2016/08/05
442
0
java线程状态转换/同步与锁

Java线程的转换: 线程状态总的可分为五大状态:分别是生、死、可运行、运行、等待/阻塞。 1、 新状态:线程对象已经创建,还没有调用start()方法 2、 可运行状态:当线程有资格运行,但调度...

晨曦之光
2012/05/16
272
0

没有更多内容

加载失败,请刷新页面

加载更多

只需一步,在Spring Boot中统一Restful API返回值格式与统一处理异常

统一返回值 在前后端分离大行其道的今天,有一个统一的返回值格式不仅能使我们的接口看起来更漂亮,而且还可以使前端可以统一处理很多东西,避免很多问题的产生。 比较通用的返回值格式如下:...

晓月寒丶
昨天
59
0
区块链应用到供应链上的好处和实际案例

区块链可以解决供应链中的很多问题,例如记录以及追踪产品。那么使用区块链应用到各产品供应链上到底有什么好处?猎头悬赏平台解优人才网小编给大家做个简单的分享: 使用区块链的最突出的优...

猎头悬赏平台
昨天
28
0
全世界到底有多少软件开发人员?

埃文斯数据公司(Evans Data Corporation) 2019 最新的统计数据(原文)显示,2018 年全球共有 2300 万软件开发人员,预计到 2019 年底这个数字将达到 2640万,到 2023 年达到 2770万。 而来自...

红薯
昨天
65
0
Go 语言基础—— 通道(channel)

通过通信来共享内存(Java是通过共享内存来通信的) 定义 func service() string {time.Sleep(time.Millisecond * 50)return "Done"}func AsyncService() chan string {retCh := mak......

刘一草
昨天
58
0
Apache Flink 零基础入门(一):基础概念解析

Apache Flink 的定义、架构及原理 Apache Flink 是一个分布式大数据处理引擎,可对有限数据流和无限数据流进行有状态或无状态的计算,能够部署在各种集群环境,对各种规模大小的数据进行快速...

Vincent-Duan
昨天
60
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部