Thread线程控制之sleep、join、setDaemon方法的用处

Thread线程控制之sleep、join、setDaemon方法的用处

1. sleep方法

public static void sleep(long millis) throws InterruptedException

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

异常　IllegalArgumentException - 如果 millis值为负数

InterruptedException - 如果任何线程中断当前线程。 当抛出此异常时，当前线程的中断状态将被清除。

下面将使用sleep方法使线程暂停指定的秒数（两秒）

 1 package com.tianjh.thread;
 2 
 3 
 4 /**
 5  * Created on 2021/1/11
 6  * 定义一个类MyThread继承Thread类
 7  * 在MyThread类中重写run()方法
 8  *
 9  * @author tianjh
10  */
11 public class MyThread extends Thread {
12 
13     public MyThread() {
14     }
15 
16     public MyThread(String name) {
17         /*
18          * 调用父类的带参构造方法
19          * public Thread(String name) {
20          *     init(null, null, name, 0);
21          *  }
22          */
23         super(name);
24     }
25 
26     @Override
27     public void run() {
28         for (int i = 0; i < 10; i++) {
29             // Thread类的getName()方法: 返回此线程的名称
30             System.out.println(getName() + ":" + i);
31             try {
32                 // 使线程停留两秒之后在执行
33                 Thread.sleep(2000);
34             } catch (InterruptedException e) {
35                 e.printStackTrace();
36             }
37         }
38     }
39 
40     public static void main(String[] args) {
41         // 1.创建MyThread类的对象
42         MyThread myThread1 = new MyThread("线程1");
43         MyThread myThread2 = new MyThread("线程2");
44         MyThread myThread3 = new MyThread("线程3");
45 
46         // 2.启动线程
47         myThread1.start();
48         myThread2.start();
49         myThread3.start();
50 
51     }
52 }

测试结果：

 Thread.sleep(-2000); 该方法的参数值要有效（不能为负数），否则会抛出异常。

2. join方法

public final void join() throws InterruptedException

异常 InterruptedException - 如果任何线程中断当前线程。 当抛出此异常时，当前线程的中断状态将被清除。

下例是当myThread1死亡之后才执行其它线程，还未死亡之前是不能执行其它任何线程的。

 1 package com.tianjh.thread;
 2 
 3 
 4 /**
 5  * Created on 2021/1/11
 6  * 定义一个类MyThread继承Thread类
 7  * 在MyThread类中重写run()方法
 8  *
 9  */
10 public class MyThread extends Thread {
11 
12     public MyThread() {
13     }
14 
15     public MyThread(String name) {
16         super(name);
17     }
18 
19     @Override
20     public void run() {
21         for (int i = 0; i < 10; i++) {
22             System.out.println(getName() + ":" + i);
23         }
24     }
25 
26     public static void main(String[] args) {
27         // 1.创建MyThread类的对象
28         MyThread myThread1 = new MyThread("线程1");
29         MyThread myThread2 = new MyThread("线程2");
30         MyThread myThread3 = new MyThread("线程3");
31 
32         // 2.启动线程
33         myThread1.start();
34         try {
35             // 等待myThread1线程死亡,只有当该线程死亡之后才能继续执行其它线程
36             myThread1.join();
37         } catch (InterruptedException e) {
38             e.printStackTrace();
39         }
40         myThread2.start();
41         myThread3.start();
42 
43     }
44 }

测试结果：

3. setDaemon

public final void setDaemon(boolean on)

参数　on - 如果 true ，将此线程标记为守护线程

异常

IllegalThreadStateException - 如果这个线程是 alive

SecurityException - 如果 checkAccess()确定当前线程不能修改此线程  

 1 package com.tianjh.thread;
 2 
 3 
 4 /**
 5  * Created on 2021/1/11
 6  * 定义一个类MyThread继承Thread类
 7  * 在MyThread类中重写run()方法
 8  *
 9  */
10 public class MyThread extends Thread {
11 
12     public MyThread() {
13     }
14 
15     public MyThread(String name) {
16         super(name);
17     }
18 
19     @Override
20     public void run() {
21         for (int i = 0; i < 100; i++) {
22             System.out.println(getName() + ":" + i);
23         }
24     }
25 
26     public static void main(String[] args) {
27         // 1.创建MyThread类的对象
28         MyThread myThread1 = new MyThread("线程1");
29         MyThread myThread2 = new MyThread("线程2");
30 
31         // 设置当前main为主线程
32         Thread.currentThread().setName("主线程");
33 
34         /*
35          * 设置为守护线程
36          * 当运行的剩余线程都是守护进程线程时，Java虚拟机将退出。
37          * 也就是当main线程执行完之后就只剩myThread1、myThread2线程了，它们都是守护线程，
38          * 所以此时JVM会退出，也就不再继续执行其它线程了
39          * 线程启动前必须调用setDaemon()方法
40          */
41         myThread1.setDaemon(true);
42         myThread2.setDaemon(true);
43 
44         // 2.启动线程
45         myThread1.start();
46         myThread2.start();
47 
48         // 让主线程执行10次
49         for (int i = 0; i < 10; i++) {
50             System.out.println(Thread.currentThread().getName() + ":" + i);
51         }
52 
53     }
54 }

测试结果：

public final boolean isDaemon()

测试这个线程是否是守护线程。

结果　　

true：如果这个线程是一个守护线程;

false：不是守护线程。

1         myThread1.setDaemon(true);
2         myThread2.setDaemon(true);
3 
4         // 2.启动线程
5         myThread1.start();
6         myThread2.start();
7 
8         System.out.println("myThread1线程是否为守护线程？ "+myThread1.isDaemon());

测试结果：