1.4 多线程 - 控制线程

2018-07-20  本文已影响15人  Hey_Shaw

join() 线程

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

join() 方法通常由使用线程的程序调用，以将大问题划分成许多小问题，每个小问题分配一个线程。当所有的小问题都得到处理后，再调用主线程来进一步操作。

public class JoinThread extends Thread {
    // 提供一个有参数的构造器，用于设置该线程的名字
    public JoinThread(String name) {
        super(name);
    }

    // 重写run()方法，定义线程执行体
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "  " + i);
        }
    }

    public static void main(String[] args) throws Exception {
        // 启动子线程
        Thread th =new JoinThread("新线程");
        th.start();
        // th.join();  // main函数会等待th线程执行完成再开始执行，执行到19进入执行jt线程
        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);
        }
    }
}

不添加 th.join()，主线程（main）会与名为 “新线程”的子线程并发执行当主线程的循环变量 i 等于 20 时，启动名为“被Join的线程”的线程，该线程不会和 main 线程并发执行，main 线程必须等待该线程执行完成后才可以向下执行。而此时“新线程”与其并发执行。

join() 方法有如下三种重载形式：

通常很少使用第三种形式，原因有两个：程序对时间的精度无须精确到微毫秒；计算机硬件、操作系统本身也无法精确到毫微秒。

后台线程

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

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

调用 Thread 对象的 setDaemon(true)方法可将指定线程设置成后台线程。

public class DaemonThread extends Thread {
    // 定义后台线程的线程执行体与普通线程没有任何区别
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println(getName() + "  " + i);
        }
    }

    public static void main(String[] args) {
        DaemonThread t = new DaemonThread();
        // 将此线程设置成后台线程
        t.setDaemon(true); 
        // 启动后台线程
        t.start();
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "  " + i);
        }
        // -----程序执行到此处，前台线程（main线程）结束------
        // 后台线程也应该随之结束
    }
}

Thread 类还提供了一个 isDaemon() 方法，用于判断指定线程是否为后台线程。

主线程默认是前台线程，t线程默认也是前台线程。并不是所有的线程默认都是前台线程，有些线程默认就是后台线程 —— 前台线程创建的子线程默认是前台线程，后台线程创建的子线程默认是后台线程。

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

线程睡眠：sleep

如果需要让当前正在执行的线程暂停一段时间，并进入阻塞状态，则可以通过调用 Thread 类的静态 sleep() 方法来实现。sleep() 方法有两种重载形式：

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

public class SleepTest{
    public static void main(String[] args) throws Exception{
        for (int i = 0; i < 10 ; i++ ){
            System.out.println("当前时间: " + new Date());
            // 调用sleep方法让当前线程暂停1s。
            Thread.sleep(1000);
        }
    }
}

线程让步：yield

与sleep() 方法类似，是Thread的静态方法，也可以让当前正在执行的线程暂停，但它不会阻塞线程，只会将线程转入就绪状态。yield() 只是让当前线程暂停一下，让系统的调度器重新调度一次，完全可能的情况是：当某个线程调用了 yield() 方法暂停之后，线程调度器又将其调度出来重新执行。

当线程调用了 yield() 方法暂停之后，只有优先级与当前线程相同，或者更高的处于就绪状态的线程才会获得执行的机会。

public class YieldTest extends Thread{

    public YieldTest(String name)   {
        super(name);
    }
    // 定义run方法作为线程执行体
    public void run()   {
        for (int i = 0; i < 50 ; i++ ) {
            System.out.println(getName() + "  " + i);
            // 当i等于20时，使用yield方法让当前线程让步
            if (i == 20) {
                Thread.yield();   ❶
            }
        }
    }
    public static void main(String[] args)throws Exception {
        // 启动两条并发线程
        YieldTest yt1 = new YieldTest("高级");
        // 将ty1线程设置成最高优先级
        // yt1.setPriority(Thread.MAX_PRIORITY);   ❷
        yt1.start();
        YieldTest yt2 = new YieldTest("低级");
        // 将yt2线程设置成最低优先级
        // yt2.setPriority(Thread.MIN_PRIORITY);   ❸
        yt2.start();
    }
}

❶处调用 yield() 静态方法让当前正在执行的线程暂停，让系统线程调度器重新调度。❷❸处处于注释状态 —— 即两个线程的优先级完全一样，所以当一个线程试用 yield() 方法暂停后，另一个线程就会开始执行。

❷❸处注释取消后，由于高优先级线程调用 yield() 方法暂停之后，系统没有与之优先级相同的线程，或更高优先级的线程，所以该线程会继续执行。

在多 CPU 并行的环境下，yield() 方法的功能有时候并不明显，如果使用多 CPU 机器运行上面程序，则可能看不到上述现象。

关于 sleep()方法与 yield() 方法的区别如下：

改变线程优先级

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

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

public class PriorityTest extends Thread {
    // 定义一个有参数的构造器，用于创建线程时指定name
    public PriorityTest(String name) {
        super(name);
    }
    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);
            }
        }
    }
}

打印结果：

创建之初的优先级:6
低级,其优先级是：6,循环变量的值为:0
低级,其优先级是：1,循环变量的值为:1
创建之初的优先级:6
高级,其优先级是：10,循环变量的值为:0
高级,其优先级是：10,循环变量的值为:1
高级,其优先级是：10,循环变量的值为:2
低级,其优先级是：1,循环变量的值为:2
高级,其优先级是：10,循环变量的值为:3
低级,其优先级是：1,循环变量的值为:3
高级,其优先级是：10,循环变量的值为:4
高级,其优先级是：10,循环变量的值为:5
高级,其优先级是：10,循环变量的值为:6
高级,其优先级是：10,循环变量的值为:7
高级,其优先级是：10,循环变量的值为:8
高级,其优先级是：10,循环变量的值为:9
高级,其优先级是：10,循环变量的值为:10
高级,其优先级是：10,循环变量的值为:11
高级,其优先级是：10,循环变量的值为:12
...

从打印结果可以看出：

虽然 Java 提供了 10 个优先级的级别，不同操作系统上的优先级并不相同，而且也不能很好的和 Java 的 10 个优先级对应，所以尽量避免直接为线程指定优先级，应该使用 MAX_PRIORITY、MIN_PRIORITY 和 NORM_PRIORITY 三个静态常量来设置优先级，这样可以保证程序具有最好的可移植性。

上一篇 下一篇

猜你喜欢

热点阅读