【JavaEE精炼宝库】多线程（2）Thread类与常用方法

public class Main {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while(true){
                System.out.println("hello Thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        },"我是线程1");
        t.start();
    }
}

我们可以利用 jconsole 来观察这一现象。

1.2 线程中断 interrupt：

李四一旦进到工作状态，他就会按照行动指南上的步骤去进行工作，不完成是不会结束的。但有时我们需要增加一些机制，例如老板突然来电话了，说转账的对方是个骗子，需要赶紧停止转账，那张三该如何通知李四停止呢？这就涉及到我们的停止线程的方式了。

注意：终止线程，在 Java 中，都只是 “提醒，建议”，真正要不要终止，还是线程本体来进行决定。

目前常见线程中断的方式有以下两种：

1.2.1 通过共享的标记来进行沟通：

这个就是自己来实现，控制线程结束的代码。

案例如下：

public class demo1 {
    static boolean isRunning = true;
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while(isRunning){
                System.out.println("李四正在转账");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            System.out.println("还好及时停了下来");
        },"李四");
        System.out.println("让李四开始转账");
        t.start();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("老板来电话了，说对方是骗子，快停下来");
        isRunning = false;
    }
}

注意：如果把 isRunning 放在方法里面也是可以的，不过这时涉及变量捕获。变量捕获有一个前置条件，就是要求变量得是 final 修饰或者 ”事实“ final。

我们使用这种写法是有一些缺点的，假设 t 线程是 sleep 100s，甚至更长，这是 main 线程是无法及时把 t 线程终止掉的，这时就需要我们第二种方法来终止。

1.2.2 调用 interrupt() 方法来通知：

对应方法如下：

我们主要使用的是下面两个。

用法：使用第2个Thread.interrupted() 或者第3个Thread.currentThread().isInterrupted() 来代替自定义标志位。（Thread 内部包含了一个 boolean 类型的变量作为线程是否被中断的标志，它的能力比boolean 更加强大）。利用第1个 interrupt 可以把标志位从 false 改为 true，true 表示线程要终止了，false 表示线程要继续执行。

案例如下：

public class demo2 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while(!Thread.currentThread().isInterrupted()){
                System.out.println("李四正在转账");
            }
            System.out.println("还好及时停了下来");
        },"李四");
        System.out.println("让李四开始转账");
        t.start();
        System.out.println("老板来电话了，说对方是骗子，快停下来");
        t.interrupt();//进行终止
    }
}

对应效果如下：

注意：请友友们观察下面这段代码，思考一下下面代码的运行结果是什么呢？

public class demo2 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while(!Thread.currentThread().isInterrupted()){
                System.out.println("李四正在转账");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("还好及时停了下来");
        },"李四");
        System.out.println("让李四开始转账");
        t.start();
        Thread.sleep(1000);
        System.out.println("老板来电话了，说对方是骗子，快停下来");
        t.interrupt();//进行终止
    }
}

运行结果：

可以看到我们明明已经让它进行终止，但是程序抛了个异常后继续执行，这是为什么呢？

解释如下：

出现这个现象是 sleep 在搞鬼，如果代码没有 sleep 确实是直接修改了标志位就行了，但是如果有 sleep，在线程 sleep 的时候触发了 Interrupt ，sleep会被马上唤醒（并且进入异常），同时清除刚才的标志位（又改回false）。

这样做的好处是：把控制权交给程序员，当前程序是要继续执行，还是要立即结束，还是等会结束，就可以让程序员自己写代码来决定了。

1.2.3 总结：

• 如果线程因为调用 wait/join/sleep 等方法而阻塞挂起，则以 InterruptedException 异常的形式通知，清除中断标志。

• 当出现 InterruptedException 的时候，要不要结束线程取决于 catch 中代码的写法。可以选择忽略这个异常，也可以跳出循环结束线程。

• 否则，只是内部的一个中断标志被设置，thread 可以通过（不会抛异常）。

1.3 线程等待 join：

多个线程的调度顺序，在系统中是无序的（抢占式执行），我们作为程序员当然是期望程序的结果是稳定的，不应该是 ”随机“ 的。通过线程的等待，就是要能够确定线程结束的先后顺序。

对应方法如下：

简单理解就是：在哪个线程里面调用 join，这个线程就要等待 join 指向的线程执行结束。

join 里面如果不传入参数，那么就是死等。

案例如下：

public class demo4 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            for(int i = 0;i < 3;i++){
                System.out.println("我是李四");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            System.out.println("t end");
        },"李四");
        t.start();
        t.join();
        System.out.println("Main end");

    }
}

案例效果：

注意：main线程是可以被 join 的，我们只要能拿到 main 线程的引用即可，可以在 main 线程中调用 currentThread(后面马上学到)，就能拿到 main 线程的引用，进而进行操作。

1.4 线程休眠：

这是我们比较熟悉一组方法，有一点要记得，因为线程的调度是不可控的，所以，这个方法只能保证实际休眠时间是大于等于参数设置的休眠时间的。

方法如下：

下面 nanos 是纳秒单位，这个基本用不到。

线程休眠我们在前面已经使用过很多次了，这里就不再演示。

1.5 获取线程实例：

方法如下：

在哪个线程里面调用，得到的就是哪个线程对象。

获取 main 线程的案例：

public class demo5 {
    public static void main(String[] args) {
        Thread t = Thread.currentThread();
        System.out.println(t.getName());
    }
}

案例结果：

二、线程的状态

2.1 线程的所有状态：

线程的状态是一个枚举类型 Thread.State

大家可以运行下面这个代码就可以看到线程中的所有状态。

public class demo6 {
    public static void main(String[] args) {
        for(Thread.State state:Thread.State.values()){
            System.out.println(state);
        }
    }
}

2.2 线程状态含义：

• NEW：

Thread 对象有了，还没调用 start ，系统内部的线程还未创建。

• TERMINATED：

线程已经终止了，内核中的线程已经销毁了，但是 Thread 对象还在。

• RUNNABLE：

就绪状态：指的是这个线程 ”随叫随到“ 。

• WAITING：

因为死等，进入堵塞状态。

• TIMED_WAITING：

带有超时时间的等。

• BLOCKED：

进行锁竞争的时候产生的阻塞（后续会讲到，还是重点呢）。

这些状态我们可以通过 getState() 来得到，或者使用 jconsole 查看。

2.3 线程状态和状态转移的意义：

上面这张图就包含了线程的状态和转移，有许多我们还没学到，所以也不用太过关注，下面我给出简化版。

一条主线，三条支线。

案例演示：

public class demo6 {
    public static void main(String[] args) {
        final Object object = new Object();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (object) {
                    while (true) {
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }, "t1");
        t1.start();
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (object) {
                    System.out.println("hehe");
                }
            }
        }, "t2");
        t2.start();
    }
}

jconsole 观察结果如下：