文档章节

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

xiaoye08050141
 xiaoye08050141
发布于 2017/02/08 17:31
字数 1840
阅读 3
收藏 0

理解了线程同步和线程通信之后,再来看本文的知识点就会简单的多了,本文是做为传统线程知识点的一个补充。

有人会问:JDK5之后有了更完善的处理多线程问题的类(并发包),我们还需要去了解传统线程吗?

答:需要。在实际开发中,无外乎两种情况,一个是开发新内容,另一个是维护原有程序。开发新内容可以使用新的技术手段,但是我们不能保证原有程序是用什么实现的,所以我们需要了解原有的。另外一点,了解传统线程的工作原理,使我们在使用并发包时更加得心应手。

线程中断

线程中断涉及到三个方法,如下:

void interrupt()    中断线程。
static boolean interrupted()   测试当前线程是否已经中断。
boolean isInterrupted()   测试线程是否已经中断。

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

public class InterruptTest {  
    public static void main(String[] args) throws InterruptedException {  
        MyThread t = new MyThread("MyThread");  
        t.start();  
        Thread.sleep(100);// 睡眠100毫秒  
        t.interrupt();// 中断t线程  
    }  
}  

class MyThread extends Thread {  
    int i = 0;  
    public MyThread(String name) {  
        super(name);  
    }  
    public void run() {  
        while(true) {// 死循环,等待被中断  
            System.out.println(getName() + getId() + "执行了" + ++i + "次");  
        }  
    }  
}

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

public class InterruptTest {  
    public static void main(String[] args) throws InterruptedException {  
        MyThread t = new MyThread("MyThread");  
        t.start();  
        Thread.sleep(100);// 睡眠100毫秒  
        t.interrupt();// 中断t线程  
    }  
}  

class MyThread extends Thread {  
    int i = 0;  
    public MyThread(String name) {  
        super(name);  
    }  
    public void run() {  
        while(!isInterrupted()) {// 当前线程没有被中断,则执行  
            System.out.println(getName() + getId() + "执行了" + ++i + "次");  
        }  
    }  
}

这样的话,线程被顺利的中断执行了。很多人实现一个线程类时,都会再加一个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资源,让给其它线程执行,来看一个小例子:

public class YieldTest {  
    public static void main(String[] args) throws InterruptedException {  
        // 创建线程对象  
        YieldThread t1 = new YieldThread("t1");  
        YieldThread t2 = new YieldThread("t2");  
        // 启动线程  
        t1.start();  
        t2.start();  
        // 主线程休眠100毫秒  
        Thread.sleep(100);  
        // 终止线程  
        t1.interrupt();  
        t2.interrupt();  
    }  
}  

class YieldThread extends Thread {  
    int i = 0;  
    public YieldThread(String name) {  
        super(name);  
    }  
    public void run() {  
        while(!isInterrupted()) {  
            System.out.println(getName() + "执行了" + ++i + "次");  
            if(i % 10 == 0) {// 当i能对10整除时,则让步  
                Thread.yield();  
            }  
        }  
    }  
}

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

线程睡眠

线程睡眠涉及到两个方法,如下:

static void sleep(long millis)     在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)。
static void sleep(long millis, int nanos)   在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠(暂停执行)。

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

public class SleepTest {  
    public static void main(String[] args) {  
        // 创建共享对象  
        Service service = new Service();  
        // 创建线程  
        SleepThread t1 = new SleepThread("t1", service);  
        SleepThread t2 = new SleepThread("t2", service);  
        // 启动线程  
        t1.start();  
        t2.start();  
    }  
      
}  

class SleepThread extends Thread {  
    private Service service;  
    public SleepThread(String name, Service service) {  
        super(name);  
        this.service = service;  
    }  
    public void run() {  
        service.calc();  
    }  
}  

class Service {  
    public synchronized void calc() {  
        System.out.println(Thread.currentThread().getName() + "准备计算");  
        System.out.println(Thread.currentThread().getName() + "感觉累了,开始睡觉");  
        try {  
            Thread.sleep(10000);// 睡10秒  
        } catch (InterruptedException e) {  
            return;  
        }  
        System.out.println(Thread.currentThread().getName() + "睡醒了,开始计算");  
        System.out.println(Thread.currentThread().getName() + "计算完成");  
    }  
}

输出结果:

t1准备计算  
t1感觉累了,开始睡觉  
t1睡醒了,开始计算  
t1计算完成  
t2准备计算  
t2感觉累了,开始睡觉  
t2睡醒了,开始计算  
t2计算完成

 线程合并

线程合并涉及到三个方法,如下:

 void join()     等待该线程终止。
 void join(long millis)      等待该线程终止的时间最长为 millis 毫秒。
 void join(long millis, int nanos)    等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。

线程合并是优先执行调用该方法的线程,再执行当前线程,来看一个小例子:

public class JoinTest {  
    public static void main(String[] args) throws InterruptedException {  
        JoinThread t1 = new JoinThread("t1");  
        JoinThread t2 = new JoinThread("t2");  
        t1.start();  
        t2.start();  
        t1.join();  
        t2.join();  
        System.out.println("主线程开始执行!");  
    }  
}  

class JoinThread extends Thread {  
    public JoinThread(String name) {  
        super(name);  
    }  
    public void run() {  
        for(int i = 1; i <= 10; i++)  
            System.out.println(getName() + getId() + "执行了" + i + "次");  
    }  
}

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

xiaoye08050141
粉丝 1
博文 30
码字总数 17598
作品 0
深圳
后端工程师
私信 提问
从Java到JVM到OS线程睡眠

前言 Java 中有时需要将线程进入睡眠状态,这时一般我们就会通过使线程进入睡眠状态,接下去就看看执行该语句在 JVM 中做了什么。 简单例子 以下是一个简单的例子,使主线程睡眠5秒钟。 JVM ...

超人汪小建
2018/08/20
0
0
并发编程基础三--join线程,后台线程,线程睡眠,线程让步,改变线程优先级

Java的线程支持提供了很多便捷方法,如标题. 1.join线程 join线程的意思就是在当前这个线程A里,加入另一个线程B,此时A阻塞,进入就绪状态,等B完成(结束,线程死亡),A才会继续执行. 这个方法通常...

Zhao-Qian
2013/02/06
383
0
java线程状态转换/同步与锁

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

晨曦之光
2012/05/16
279
0
Java 并发:第二部分 - 多线程

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

苗哥
2013/01/29
405
0
Java 多线程编程总结

一、认识多任务、多进程、单线程、多线程 要认识多线程就要从操作系统的原理说起。 以前古老的DOS操作系统(V 6.22)是单任务的,还没有线程的概念,系统在每次只能做一件事情。比如你在cop...

鉴客
2010/12/16
1K
3

没有更多内容

加载失败,请刷新页面

加载更多

手持式人证核验设备助力国家安全系统

手持式人证核验设备,是针对公共安全领域的移动化身份核验、追逃等需求推出的手持式一体化设备。其特点是具备人员信息采集、存储和比对功能,将采集到的人脸信息与居民身份证芯片中的人脸信息...

非思丸智能FaceTo
23分钟前
4
0
好程序员web前端教程分享JavaScript简写方法

今天好程序员web前端教程为大家分享JavaScript简写方法,小伙伴们快来看一看吧。 1.三元操作符 当想写if...else语句时,使用三元操作符来代替。 constx =20; let answer; if(x >10) { answer...

好程序员官网
27分钟前
5
0
PHP面试题2019年小米工程师面试题和答案解析

一、单选题(共29题,每题5分) 1.PHP面向对象方法重写描述错误的是? A、子类必须继承父类 B、子类可以重写父类已有方法 C、重写之后子类会调用父类方法 D、子类也可以具有与父类同名的属性...

一个PHP程序媛
30分钟前
4
0
K8s 从懵圈到熟练 – 镜像拉取这件小事

导读:相比 K8s 集群的其他功能,私有镜像的自动拉取,看起来可能是比较简单的。而镜像拉取失败,大多数情况下都和权限有关。所以,在处理相关问题的时候,我们往往会轻松的说:这问题很简单...

Mr_zebra
31分钟前
4
0
分布式锁简单入门以及实现方法

学过Java多线程的应该都知道什么是锁,没学过的也不用担心,Java中的锁可以简单的理解为多线程情况下访问临界资源的一种线程同步机制。 在学习或者使用Java的过程中进程会遇到各种各样的锁的...

yanlijun_java
34分钟前
4
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部