Java多线程——线程的sleep方法、中断线程的睡眠

一、关于Sleep方法的应用

• public static void sleep(long millis) throws InterruptedException

  • 让当前正在执行的线程进入休眠（暂时停止执行）指定的毫秒数。

  • 静态方法：Thread.Sleep(1000);

    • 参数

      millis - 以毫秒为单位的睡眠时间长度

sleep() 的作用是让当前线程休眠，即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间，线程休眠的时间会大于/等于该休眠时间；在线程重新被唤醒时，它会由“阻塞状态”变成“就绪状态”，从而等待cpu的调度执行。

Sleep方法的代码实现：

public class test03 {
    public static void main(String[] args) {
        try {
            Thread.sleep(1000*5);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        //5秒后执行这里的代码
        System.out.println("hello");
        for (int i=1;i<=5;i++) {
            //每隔2秒执行一次该代码
            System.out.println(Thread.currentThread().getName()+":"+i);
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

二、Sleep的面试题

public class test03 {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();
        mr.setName("t");
        mr.start();
        try {
            //问题：这行代码会让线程mr进入休眠状态吗？
            //不会。。。。
            mr.sleep(1000*5);//这行代码在执行的时候还是会转换成Thread.Sleep(5000);
                             //这行代码的作用是：让当前进程进入休眠状态，也就是main进程进入休眠状态
                             //这行代码出现在main方法中，会让main线程休眠
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        //而是5秒之后这里才会执行：
        System.out.println("hello");
​
    }
}
class MyRunnable extends Thread{
    @Override
    public void run() {
        for (int i=1;i<=10;i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

三、终止线程的睡眠

• public void interrupt()

  • 中断此线程。

public class test03 {
    public static void main(String[] args) {
        Thread th = new Thread(new MyRunnable());
        th.setName("t");
        th.start();
        //希望5秒之后，th线程醒来
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //中断th线程的睡眠（这种中断睡眠的方式依靠了Java的异常处理机制）
        th.interrupt();//干扰
    }
}
class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("begin");
        //重点：run当中的异常不能throws，只能try  catch。
        try {
            Thread.sleep(1000*10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("end");
    }
}

四、强行终止线程的执行

不建议使用

这种方式存在很大的缺点：容易丢失数据，因为直接将线程杀死！

public class test03 {
    public static void main(String[] args) {
        Thread th = new Thread(new MyRunnable());
        th.setName("t");
        th.start();
        //模拟5秒
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //5秒之后th线程终止
        th.stop();//已过时，不建议使用。
        /*  t----->1
            t----->2
            t----->3
            t----->4
            t----->5*/
    }
}
class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i=1;i<=10;i++){
            System.out.println(Thread.currentThread().getName()+"----->"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
​
    }
}

出于这种情况，我们应该合理的终止一个线程的执行。。

五、合理的终止一个线程的执行

public class test03 {
    public static void main(String[] args) {
        MyRunnable r = new MyRunnable();
        Thread th = new Thread(r);
        th.setName("t");
        th.start();
        //模拟5秒
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //5秒之后th线程终止
        //你想要什么时候终止线程，只需要把true改为false，线程就终止了
        r.run = false;
    }
}
class MyRunnable implements Runnable{
    //定义一个布尔类型的标志
    boolean run = true;
    @Override
    public void run() {
        for (int i=1;i<=10;i++){
            if (run){
                System.out.println(Thread.currentThread().getName()+"----->"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else {
                //终止线程
                return;
            }
        }
    }
}

这种方式是很常用的，以后的开发中可能会用到的.

如果你觉得博主的文章的不错或者对你有帮助，可以点一个免费的关注支持一下博主，你的鼓励将是我创作的最大动力！！