第十六章Java多线程-16.4控制线程

Dear 丶 2023-06-20 06:46 5阅读 0赞

## 16.4控制线程 ##

Java提供线程控制的工具方法。

16.4.1 join线程

Thread提供了让一个线程等待另外一个线程完成的方法join（）方法。当在某个线程执行流中调用其他线程的join（）方法时，调用线程将被阻塞，直到被join（）方法加入的join线程执行完为止。

PS：join方法通常使用线程的程序调用，以将大问题划分成许多小问题，每个小问题分配一个线程。当所有小线程都完成后，再调用主线程来操作。

package com.cdmt.collection.list;
    
    public class JoinThread extends Thread {
    
        //提供一个带参构造器
        public JoinThread(String name){
            super(name);
        }
    
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                //获取当前线程
                System.out.println(Thread.currentThread().getName() + "---" + i);
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
            //启动子线程
            new JoinThread("新线程").start();
            for(int i = 0; i<100; i++){
                if(i == 20){
                    JoinThread jt = new JoinThread("被Join的线程");
                    jt.start();
                    //main线程调用了jt的join方法，main线程必须等待jt执行完毕
                    jt.join();
                }
                System.out.println(Thread.currentThread().getName() + "---" + i);
            }
        }
    }

结果：

![20191209112626508.png][] ![20191209112904449.png][]

总结：

共3线程，主方法开始时启动新线程，该线程将会和main线程并发执行。当主线程i变为20时，启动被Join的线程，main线程必须等待Join完成才可以执行。在被Join的线程执行时，实际上只有2个子线程并发执行，main线程处于等待状态。

join（）方法有三种重载形式：

1.  join（）：等待被join的线程执行完毕
2.  join（long millis）：等待被join的线程的时间最长为millis毫秒，如果在millis毫秒内被join的线程还没执行结束，则不再等待。
3.  join（long mills，int nanos）：等待被join的线程的时间最长为millis毫秒加nanos毫微妙

### 16.4.2 后台线程 ###

有一种线程在后天运行，它的任务就是为其他线程提供服务，这种线程被称为后天线程（Daemon Thread），又被称为守护线程或者精灵线程。JVM的垃圾回收线程就是一个典型的后台线程。

后台线程有个特征：如果所有的前台程序都死亡，后台线程会自动死亡。

调用Thread对象的setDaemon（true）方法可以将指定线程设置成后台线程。当前台线程都死亡时，后台线程随之死亡。

package com.cdmt.collection.list;
    
    public class DaemonThread extends Thread {
    
    
    
        //定义后台线程的线程执行体与普通线程没有任何区别
        @Override
        public void run() {
            for(int i=0; i<1000;i++){
                System.out.println(Thread.currentThread().getName() + "---" + i);
            }
        }
    
        public static void main(String[] args) {
            DaemonThread dt = new DaemonThread();
            //将此线程设置成后台线程
            dt.setDaemon(true);
            //启动后台线程
            dt.start();
            for(int i=0;i<10;i++){
                System.out.println(Thread.currentThread().getName() + "---" + i);
            }
            //程序执行到此处，前台线程main结束
            //后台线程也应该随之结束
        }
    }

结果：

![20191209114345726.png][]![20191209122824200.png][]

总结：

本来子线程要到999才会结束，但是由于前天线程全部死了，所以后台线程也就被JVM杀死。

PS：前台线程死亡后JVM通知后台线程死亡，但从它接收指令到做出响应，需要一定时间而且要将某个线程设直为后台线程，必须在该线程启动之前设置，也就是说setDaemon( true) 须在 start() 方法之前调用，否则会引发IllegalThreadStateException异常。

### 16.4.3 线程睡眠：sleep ###

如果需要让当前执行的线程 暂停一段时间，并进入阻塞状态，则可以通过调用Thread类的静态sleep（）方法实现。

sleep有2种重载形式：

1.  static void sleep（long millis）：让当前正在执行的线程暂停millis毫秒，并进入阻塞状态，该方法受到系统计时器和线程调度器的精度与准度影响
2.  static void sleep（long millis， int nanos）：让当正在执行的线程暂停millis毫秒加nanos毫微妙，该方法受到系统计时器和线程调度器的精度与准度影响

与前面类似的是，程序很少调用第二种形式的sleep方法。

当前线程调用sleep方法进入阻塞状态后，在其睡眠时间段内，该线程不会获得执行的机会，即使系统中没有其他可执行的线程，处于sleep方法中的线程也不会执行，因此sleep方法常用来暂停程序的执行。

package com.cdmt.collection.list;
    
    import java.util.Date;
    
    public class SleepTest extends Thread {
        public static void main(String[] args) throws InterruptedException {
            for(int i=0;i<10;i++){
                System.out.println("当前时间是： "  + new Date());
                Thread.sleep(2000);
            }
        }
    }

结果：

![20191209135528561.png][]

总结:

系统完全让出资源，每2s之后继续调用执行。yeild（）方法只是让线程进入就绪状态，优先级比当前线程大或者相等的才可以得到资源。否则线程会继续执行。

### 16.4.4 改变线程优先级 ###

每个线程都有优先级，优先级高的线程获得执行机会比较多。每个线程默认的优先级都与创建它的父线程的优先级相同，在默认情况下，main线程具有普通优先级，由main线程创建的子线程也具有普通优先级。

Thread提供了setPriority（int newPriority）、getPriority（）方法来设置和返回指定线程的优先级，其中setPriority（）方法的参数可以是一个整数，范围是1-10之间，也可以使用Thread类如下的三个静态常量。

1.  MAX\_PRIORITY：其值是10
2.  MIN\_PRIORITY：其值是1
3.  NORM\_PRIORITY：其值是5

下面程序使用了setPriority方法来改变主线程的优先级

package com.cdmt.collection.list;
    
    public class PriorityTest extends Thread {
    
        //定义一个有参数的构造器，用于创建线程时指定name
        public PriorityTest(String name){
            super(name);
        }
    
        @Override
        public void run() {
            for(int i=0;i<50;i++){
                System.out.println(getName() + "，其优先级是： " + getPriority() + "，循环变量的值为：" + i);
            }
        }
    
        public static void main(String[] args) {
            Thread.currentThread().setPriority(6);
            for(int i=0; i<30; i++){
                if(i==10){
                    PriorityTest low = new PriorityTest("低级");
                    low.start();
                    System.out.println("创建之初的优先级： " + low.getPriority());
                    low.setPriority(Thread.MIN_PRIORITY);
                }
                if(i==20){
                    PriorityTest high = new PriorityTest("高级");
                    high.start();
                    System.out.println("创建之初的优先级： " + high.getPriority());
                    high.setPriority(Thread.MAX_PRIORITY);
                }
            }
        }
    }

结果：

![20191209142010321.png][]

总结：

设置高的优先级有限运行。

[20191209112626508.png]: https://img-blog.csdnimg.cn/20191209112626508.png
[20191209112904449.png]: https://img-blog.csdnimg.cn/20191209112904449.png
[20191209114345726.png]: https://img-blog.csdnimg.cn/20191209114345726.png
[20191209122824200.png]: https://img-blog.csdnimg.cn/20191209122824200.png
[20191209135528561.png]: https://img-blog.csdnimg.cn/20191209135528561.png
[20191209142010321.png]: https://img-blog.csdnimg.cn/20191209142010321.png