Java多线程系列—线程的运行机制(02)

短命女 2023-01-18 06:46 110阅读 0赞

## 线程的运行机制 ##

在这一节我们主要学习一下线程的启动，线程的停止以及线程的状态流转

### 线程的启动 ###

#### start 方法和 run 方法 ####

这个其实是一个非常老生常谈的问题了，就是说我们只有调用start 方法才会帮我们启动一个线程，如果你是直接调用run 方法的话，那其实就是同步调用。

public class StartRight { 
        public static void main(String[] args) { 
            Thread t1 = new Thread(() -> { 
                String name = Thread.currentThread().getName();
                System.out.println(name + "开始执行");
                try { 
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                System.out.println(name + "执行结束");
            });
    
            Thread t2 = new Thread(() -> { 
                String name = Thread.currentThread().getName();
                System.out.println(name + "开始执行");
                try { 
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                System.out.println(name + "执行结束");
            });
    
            run(t1, t2);
            System.out.println("==========================");
            start(t1, t2);
        }
    
        public static void run(Thread t1, Thread t2) { 
            t1.run();
            t2.run();
        }
    
        public static void start(Thread t1, Thread t2) { 
            t1.start();
            t2.start();
        }
    }

输出结果如下：我们看到run 方法本质还是在主线程里面执行，start 才是真正的启动了多个线程

main开始执行
    main执行结束
    main开始执行
    main执行结束
    ==========================
    Thread-0开始执行
    Thread-1开始执行
    Thread-0执行结束
    Thread-1执行结束

#### 多次启动 ####

我们先看一下多次启动会出现什么

public class ThreadStartTimes { 
        public static void main(String[] args) { 
            Runnable target;
            Thread thread = new Thread(()->{ 
                System.out.println(Thread.currentThread().getName());
            });
    
            thread.start();
            System.out.println(1);
            thread.start();
            System.out.println(2);
            thread.start();
            System.out.println(3);
        }
    }

输出如下:

1
    Thread-0
    Exception in thread "main" java.lang.IllegalThreadStateException
    	at java.lang.Thread.start(Thread.java:708)
    	at thread.thread.ThreadStartTimes.main(ThreadStartTimes.java:12)

我们看到报错了,那我们看一下这个方法的实现

public synchronized void start() { 
        /** * 也就是说我们的线程如果处在新建的状态下(NEW)，threadStatus是0,其他状态下的线程是不能调用start 方法的 * A zero status value corresponds to state "NEW". */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
    
        /* Notify the group that this thread is about to be started * so that it can be added to the group's list of threads * and the group's unstarted count can be decremented. */
        group.add(this);
    
        boolean started = false;
        try { 
            start0();
            started = true;
        } finally { 
            try { 
                if (!started) { 
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) { 
                /* do nothing. If start0 threw a Throwable then it will be passed up the call stack */
            }
        }
    }

也就是说如果我们的线程在第一次调用start 方法之后threadStatus以及不是0了，那这个时候你如果再去调用这个方法的话，就会报错。但是需要注意的是你在Thread 代码里面看不到状态的变更，也就是说状态的变更是由local 方法维护的

### 线程的停止 ###

想要启动线程需要调用 Thread 类的 start() 方法，并在 run() 方法中定义需要执行的任务。启动一个线程非常简单，但如果想要正确停止它就没那么容易了。

通常情况下，我们不会手动停止一个线程，而是允许线程运行到结束，然后让它自然停止。但是依然会有许多特殊的情况需要我们提前停止线程，比如：用户突然关闭程序，或程序运行出错重启等。在这种情况下，即将停止的线程在很多业务场景下仍然很有价值。尤其是我们想写一个健壮性很好，能够安全应对各种场景的程序时，正确停止线程就显得格外重要。但是Java 并没有提供简单易用，能够直接安全停止线程的能力

#### interrupt ####

对于 Java 而言，最正确的停止线程的方式是使用 interrupt。但 interrupt 仅仅起到通知被停止线程的作用。而对于被停止的线程而言，它拥有完全的自主权，它既可以选择立即停止，也可以选择一段时间后停止，也可以选择压根不停止。那么为什么 Java 不提供强制停止线程的能力呢？

事实上，Java 希望程序间能够相互通知、相互协作地管理线程，因为如果不了解对方正在做的工作，贸然强制停止线程就可能会造成一些安全的问题，为了避免造成问题就需要给对方一定的时间来整理收尾工作。比如：线程正在写入一个文件，这时收到终止信号，它就需要根据自身业务判断，是选择立即停止，还是将整个文件写入成功后停止，而如果选择立即停止就可能造成数据不完整，不管是中断命令发起者，还是接收者都不希望数据出现问题。

##### 如何用 interrupt 停止线程 #####

我们需要使用下面这样的代码设计，去感知程序有没有让线程停止

while (!Thread.currentThread().isInterrupted() && more work to do) {
    
        do more work
    
    }

明白 Java 停止线程的设计原则之后，我们看看如何用代码实现停止线程的逻辑。我们一旦调用某个线程的 interrupt() 之后，这个线程的中断标记位就会被设置成 true。每个线程都有这样的标记位，当线程执行时，应该定期检查这个标记位，如果标记位被设置成 true，就说明有程序想终止该线程。

可以看到下面代码在 while 循环体判断语句中，首先通过 Thread.currentThread().isInterrupt() 判断线程是否被中断，随后检查是否还有工作要做。&& 逻辑表示只有当两个判断条件同时满足的情况下，才会去执行下面的工作。

public class StopThread implements Runnable{ 
        @Override
        public void run() { 
            int count = 0;
            while (!Thread.currentThread().isInterrupted() && count < 1000) { 
                System.out.println("count = " + count++);
            }
        }
    
        public static void main(String[] args) throws InterruptedException { 
            Thread thread = new Thread(new StopThread());
              
            thread.start();
            // 为了不让主线程退出,从而方便观察子线程的输出
            Thread.sleep(5);
            // 停止子线程
            
            thread.interrupt();
        }
    }

在 StopThread 类的 run() 方法中，首先判断线程是否被中断，然后判断 count 值是否小于 1000。这个线程的工作内容很简单，就是打印 0~999 的数字，每打印一个数字 count 值加 1，可以看到，线程会在每次循环开始之前，检查是否被中断了。接下来在 main 函数中会启动该线程，然后休眠 5 毫秒后立刻中断线程，该线程会检测到中断信号，于是在还没打印完1000个数的时候就会停下来，这种就属于通过 interrupt 正确停止线程的情况。

##### sleep 期间能否感受到中断 #####

如果线程在执行任务期间有休眠需求，也就是每打印一个数字，就进入一次 sleep ，而此时将 Thread.sleep() 的休眠时间设置为 1000 秒钟。

public class StopDuringSleep { 
    
        public static void main(String[] args) throws InterruptedException { 
            canStopWhileSleep();
        }
    
    
        public static void canStopWhileSleep() throws InterruptedException { 
            Runnable runnable = () -> { 
                int num = 0;
                try { 
                    while (!Thread.currentThread().isInterrupted() && num <= 1000) { 
                        System.out.println(num);
                        num++;
                        Thread.sleep(1000000);
                    }
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            };
    
            Thread thread = new Thread(runnable);
    
            thread.start();
            // 为了不让主线程退出,从而方便观察子线程的输出
            Thread.sleep(5);
            thread.interrupt();
    
        }
    }

主线程休眠 5 毫秒后，通知子线程中断，此时子线程仍在执行 sleep 语句，处于休眠中。那么就需要考虑一点，在休眠中的线程是否能够感受到中断通知呢？是否需要等到休眠结束后才能中断线程呢？如果是这样，就会带来严重的问题，因为响应中断太不及时了。正因为如此，Java 设计者在设计之初就考虑到了这一点。

如果调用了sleep、wait 等方法是线程进入休眠状态，这个时候线程是可以感受到中断信号的，并且会抛出一个 InterruptedException 异常，同时清除中断信号，将中断标记位设置成 false。这样一来就不用担心长时间休眠中线程感受不到中断了，因为即便线程还在休眠，仍然能够响应中断通知，并抛出异常。

#### 错误的停止方法 ####

首先，我们来看几种停止线程的错误方法。比如 stop()，suspend() 和 resume()，这些方法已经被 Java 直接标记为 @Deprecated。如果再调用这些方法，IDE 会友好地提示，我们不应该再使用它们了。但为什么它们不能使用了呢？是因为 stop() 会直接把线程停止，这样就没有给线程足够的时间来处理想要在停止前保存数据的逻辑，**任务戛然而止，会导致出现数据完整性等问题**。

也就是Thread.currentThread().isInterrupted()可以给用户一个自控的环节，可以将当前任务处理完成之后再停止。

而对于 suspend() 和 resume() 而言，它们的问题在于如果线程调用 suspend()，它并不会释放锁，就开始进入休眠，但此时有可能仍持有锁，这样就容易导致死锁问题，因为这把锁在线程被 resume() 之前，是不会被释放的。假设线程 A 调用了 suspend() 方法让线程 B 挂起，线程 B 进入休眠，而线程 B 又刚好持有一把锁，此时假设线程 A 想访问线程 B 持有的锁，但由于线程 B 并没有释放锁就进入休眠了，所以对于线程 A 而言，此时拿不到锁，也会陷入阻塞，那么线程 A 和线程 B 就都无法继续向下执行。正是因为有这样的风险，所以 suspend() 和 resume() 组合使用的方法也被废弃了。

#### volatile 停止线程 ####

这里我们是通过volatile来修饰一个布尔值，也就是是线程是否停止的标记，这样在运行的时候程序就可以判断该值是否为true,从而判断是否停止

public class StopThreadByVolatile implements Runnable{ 
    
        private volatile boolean canceled = false;
    
        @Override
        public void run() { 
            int num = 0;
            try { 
                while (!canceled && num <= 1000000) { 
                    if (num % 10 == 0) { 
                        System.out.println(num + "是10的倍数");
                    }
                    num++;
                    Thread.sleep(1);
                }
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
        }
    
        public static void main(String[] args) throws InterruptedException { 
            StopThreadByVolatile r = new StopThreadByVolatile();
            Thread thread = new Thread(r);
            thread.start();
            Thread.sleep(3000);
            r.canceled = true;
        }
    }

从输出我们已经看到程序停止了

... 
    2300是10的倍数
    2310是10的倍数
    2320是10的倍数
    2330是10的倍数
    2340是10的倍数
    2350是10的倍数
    2360是10的倍数
    2370是10的倍数
    2380是10的倍数

通过上面的代码我们其实可以判断处理啊，volatile的的变量是没有办法在休眠状态的时候进行响应的，这也是其不足之处，因为从上面的实现来看，要想退出线程必须是在线程运行的时候，也就是说是在线程运行到判断变量的时候，既然如此我们就不能在任何场景下都去使用volatile的方式去停止线程。

##### volatile 停止线程的不足 #####

前面我们也说过了，volatile是没有办法在程序休眠的时候进行响应的，往往我们的休眠是在不满足程序的运行条件的时候才进行休眠，那这个时候如果我们想要取消程序，那就是不可能做到了

下面我们模拟一个ETL 的任务,因为是模拟所以我每次等待5s,真实情况应该每次等待的时间更多

public class StopThreadByVolatileNotPerfect implements Runnable { 
    
        private volatile boolean canceled = false;
        private volatile boolean isExisting = false;
        private volatile boolean isSuccess = false;
    
        @Override
        public void run() { 
            int num = 0;
            try { 
                while (!canceled && num <= 9) { 
                    if (!isExisting) { 
                        System.out.println("文件不存在,即将等待5秒钟,已经等待了:" + num * 5 + " 秒钟,");
                    } else { 
                        System.out.println("文件存在，开始处理 ....");
                        // 模拟处理
                        TimeUnit.MILLISECONDS.sleep(30);
                        System.out.println("文件处理完毕");
                        isSuccess = true;
                    }
                    num++;
                    TimeUnit.SECONDS.sleep(5);
                }
    
                if (canceled) { 
                    isSuccess = true;
                }
    
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
        }
    
        public static void main(String[] args) throws InterruptedException { 
            StopThreadByVolatileNotPerfect r = new StopThreadByVolatileNotPerfect();
            Thread thread = new Thread(r);
            thread.start();
            TimeUnit.SECONDS.sleep(20);
            System.out.println("业务方告知今天没有数据，任务可以跳过");
            r.canceled = true;
            System.out.println("任务执行结果:"+r.isSuccess);
            TimeUnit.SECONDS.sleep(2);
            System.out.println("任务执行结果:"+r.isSuccess);
        }
    }

这里其实就是想要我们如果因为一些已知的原因取消了(skip)程序，但是因为线程已经进入等待，所以必须要等子线程唤醒之后才能响应我们的取消操作，而这个时候可能已经过去很久了,下面是输出。

文件不存在,即将等待5秒钟,已经等待了:0 秒钟,
    文件不存在,即将等待5秒钟,已经等待了:5 秒钟,
    文件不存在,即将等待5秒钟,已经等待了:10 秒钟,
    文件不存在,即将等待5秒钟,已经等待了:15 秒钟,
    业务方告知今天没有数据，任务可以跳过
    任务执行结果:false
    任务执行结果:true

但是如果你将上面的等待时间改成了30分钟，那你必须等待30分钟后才能拿到正确的结果，其实这是对业务来说是不可接受的。

### 线程的状态 ###

就像生物从出生到长大、最终死亡的过程一样，线程也有自己的生命周期，在 Java 中线程的生命周期中一共有 6 种状态。从前面我们了解到了线程其实是有状态变更的，所以导致了我们的同一个线程不能重复启动，下面我们看一下这些状态的流转与定义，

public enum State { 
        NEW,
        RUNNABLE,
        BLOCKED,
        WAITING,
        TIMED_WAITING,
        TERMINATED;
    }

![线程状态转换][a60387b00a3e1a3440e32d65e4158607.png]

[a60387b00a3e1a3440e32d65e4158607.png]: /images/20221021/580399bef3a74416bdd24bf757215d10.png