(Java 高并发程序设计) 一篇文章带你深入了解 Java 中线程的基本操作

悠悠 2022-12-21 02:28 109阅读 0赞

### 文章目录 ###

*   *  一、新建线程
     *  二、终止线程
     *  三、线程中断
     *  四、等待(wait)和通知(notify)
     *  五、挂起(suspend)和继续执行(resume)线程
     *  六、等待线程结束（join）和谦让（yeild）
     *   *  1. join
         *  2. yeild

## 一、新建线程 ##

新建线程很简单。只要使用`new`关键字创建一个线程对象，并且将它`start()`起来即可。

Thread t = new Thread();
    t.start();

那么线程s`tart()`后，会干什么呢？这才是问题的关键。线程Thread，有一个`run()`方法，`start()`方法就会新建一个线程并让这个线程执行`run()`方法。这里要注意，下面的代码通过编译，也能正常执行。但是，却不能新建一个线程，而是在当前线程中调用`run()`方法，只是作为一个普通的方法调用。

Thread t = new Thread();
    t.run();

在这里希望大家特别注意，调用`start()`方法和直接调用`run()`方法的区别。  
不要用run()方法来开启新线程。它只会在当前线程中串行执行run()方法中的代码。

在默认情况下，线程Thread的`run()`方法什么都没有做，因此，这个线程一启动就马上结束了。如果你想让线程做点什么，就必须重写`run()`方法，把你的“任务”填进去。

Thread t = new Thread(){ 
    	@Override
    	public void run(){ 
    		System.out.println("Hello ,Yolo!");
    	}
    };
    t.start();

上述代码使用匿名内部类，重写了`run()`方法，并要求线程在执行时打印“Hello, Yolo!”的字样。如果没有特别的需要，都可以通过继承线程Thread，重写`run()`方法来自定义线程。但考虑到Java是单继承的，也就是说继承本身也是一种很宝贵的资源，因此，我们也可以使用Runnable接口来实现同样的操作。Runnable接口是一个单方法接口，它只有一个run()方法：

public interface Runnable{ 
    	public abstract void run();
    }

此外，Thread类有一个非常重要的构造方法：`public Thread(Runnable target)`

它传入一个`Runnable`接口的实例，在`start()`方法调用时，新的线程就会执行`Runnable.run()`方法。实际上，默认的`Thread.run()`方法就是这么做的：

public void run(){ 
    	if(target != null){ 
    		target.run();
    	}
    }

注意：默认的`Thread.run()`方法就是直接调用内部的`Runnable`接口。因此，使用Runnable接口告诉线程该做什么，更为合理。

![在这里插入图片描述][20201113210151910.png_pic_center]

上述代码实现了Runnable接口，并将该实例传入线程Thread中。这样避免重写`Thread.run()`方法，单纯使用接口来定义线程Thread，也是最常用的做法。

## 二、终止线程 ##

一般来说，线程执行完毕就会结束，无须手工关闭。但是，凡事都有例外。一些服务端的后台线程可能会常驻系统，它们通常不会正常终结。比如，它们的执行体本身就是一个大大的无穷循环，用于提供某些服务。

那么如何正常地关闭一个线程呢？查阅JDK，你不难发现线程Thread提供了一个`stop()`方法。如果你使用`stop()`方法，就可以立即将一个线程终止，非常方便。但如果你使用Eclipse之类的IDE写代码，就会发现stop()方法是一个被标注为废弃的方法。也就是说，在将来，JDK可能就会移除该方法。

为什么`stop()`方法被废弃而不推荐使用呢？原因是`stop()`方法过于暴力，强行把执行到一半的线程终止，可能会引起一些数据不一致的问题

为了让大家更好地理解本节内容，我先简单介绍一些有关数据不一致的概念。假设我们在数据库里维护着一张用户表，里面记录了用户ID和用户名。假设这里有两条记录：  
![在这里插入图片描述][20201113210553283.png_pic_center]  
如果我们用一个User对象去保存这些记录，我们总是希望这个对象要么保存记录1，要么保存记录2。如果这个User对象一半存着记录1，另外一半存着记录2，我想大部分人都会抓狂吧！如果现在真的由于程序问题，出现了这么一个怪异的对象u，u的ID是1，但是u的NAME是小王。那么，在这种情况下，数据就已经不一致了，说白了就是系统有错误了。这种情况是相当危险的，如果我们把一个不一致的数据直接写入了数据库，那么就会造成数据永久地被破坏和丢失，后果不堪设想。

也许有人会问，怎么可能呢？跑得好好的系统，怎么会出现这种问题呢？在单线程环境中，确实不会，但在并行程序中，如果考虑不周，就有可能出现类似的情况。不经思考地使用`stop()`方法就有可能导致这种问题。`Thread.stop()`方法在结束线程时，会直接终止线程，并立即释放这个线程所持有的锁，而这些锁恰恰是用来维持对象一致性的。如果此时，写线程写入数据正写到一半，并强行终止，那么对象就会被写坏，同时，由于锁已经被释放，另外一个等待该锁的读线程就顺理成章地读到了这个不一致的对象，悲剧也就此发生。整个过程如图2.4所示。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center]  
首先，对象u持有ID和NAME两个字段，假设当ID等于NAME时表示对象是一致的，否则表示对象出错。写线程总是会将ID和NAME写成相同的值，并且在这里初始值都为0。当写线程在写对象时，读线程由于无法获得锁，因此必须等待，所以读线程是看不见一个写了一半的对象的。当写线程写完ID后，很不幸地被stop()，此时对象u的ID为1而NAME仍然为0，处于不一致状态。而被终止的写线程简单地将锁释放，读线程争夺到锁后，读取数据，于是，读到了ID=1而NAME=0的错误值。

如果需要停止一个线程，那么应该怎么做呢？其实方法很简单，只需要由我们自行决定线程何时退出就可以了。只需要将ChangeObjectThread线程增加一个`stopMe()`方法即可。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center 1]  
第2行代码定义了一个标记变量stopme，用于指示线程是否需要退出。当stopMe()方法被调用，stopme就被设置为true，此时，在第10行代码检测到这个改动时，线程就自动退出了。使用这种方式退出线程，不会使对象u的状态出现错误。因为，ChangeObjectThread已经没有机会“写坏”对象了，它总是会选择在一个合适的时间终止线程。

## 三、线程中断 ##

在Java中，线程中断是一种重要的线程协作机制。从表面上理解，中断就是让目标线程停止执行的意思，实际上并非完全如此。在上面，我们已经详细讨论了stop()方法停止线程的坏处，并且使用了一套自有的机制完善线程退出的功能。

在JDK中是否有提供更强大的支持呢？答案是肯定的，那就是线程中断。严格地讲，线程中断并不会使线程立即退出，而是给线程发送一个通知，告知目标线程，有人希望你退出啦！至于目标线程接到通知后如何处理，则完全由目标线程自行决定。这点很重要，如果中断后，线程立即无条件退出，我们就又会遇到stop()方法的老问题。

有三个方法与线程中断有关，这三个方法看起来很像，可能会引起混淆和误用，希望大家注意。

public void Thread.interrupt();//中断线程
    public boolean Thread.isInterrupted();//判断是否被中断
    public static boolean Thread.interrupted();//判断是否被中断，并清除当前中断状态

`Thread.interrupt()`方法是一个实例方法。它通知目标线程中断，也就是设置中断标志位。中断标志位表示当前线程已经被中断了。`Thread.isInterrupted()`方法也是实例方法，它判断当前线程是否被中断（通过检查中断标志位）。最后的静态方法`Thread.interrupted()`也可用来判断当前线程的中断状态，但同时会清除当前线程的中断标志位状态。

下面这段代码对t1线程进行了中断，那么中断后t1会停止执行吗？

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center 2]  
在这里，虽然对t1进行了中断，但是在t1中并没有中断处理的逻辑，因此，即使t1线程被置为中断状态，这个中断也不会发生任何作用。如果希望t1在中断后退出，就必须为它增加相应的中断处理代码：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center 3]  
上述代码的加粗部分使用`Thread.isInterrupted()`函数判断当前线程是否被中断了，如果是，则退出循环体，结束线程。这看起来与前面增加stopme标记的手法非常相似，但是中断的功能更为强劲。如果在循环体中，出现了类似于`wait()`方法或者`sleep()`方法这样的操作，则只能通过中断来识别了。

下面，先来了解一下`Thread.sleep()`函数，它的代码如下：

public static native void sleep(long millis) throws InterruptedException;

`Thread.sleep()`方法会让当前线程休眠若干时间，它会抛出一个`InterruptedException`中断异常。`InterruptedException`不是运行时异常，也就是说程序必须捕获并且处理它，当线程在`sleep()`休眠时，如果被中断，这个异常就会产生。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center 4]  
注意上面代码中第10～15行，如果线程在第11行代码处被中断，则程序会抛出异常，并进入第13行代码处理。  
在catch子句部分，由于已经捕获了中断，我们可以立即退出线程。但在这里，我们并没有这么做，因为也许在这段代码中，我们还必须进行后续的处理来保证数据的一致性和完整性，因此，执行了`Thread.interrupt()`方法再次中断自己，置上中断标记位。只有这么做，在第6行代码的中断检查中，才能发现当前线程已经被中断了。

注意：`Thread.sleep()`方法由于中断而抛出异常，此时，它会清除中断标记，如果不加处理，那么在下一次循环开始时，就无法捕获这个中断，故在异常处理中，再次设置中断标记位。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70]

## 四、等待(wait)和通知(notify) ##

为了支持多线程之间的协作，JDK提供了两个非常重要的接口线程：等待`wait()`方法和通知`notify()`方法。这两个方法并不是在Thread类中的，而是输出Object类。这也意味着任何对象都可以调用这两个方法

![在这里插入图片描述][20201113214252886.png_pic_center]

当在一个对象实例上调用`wait()`方法后，当前线程就会在这个对象上等待。这是什么意思呢？  
比如，在线程A中，调用了`obj.wait()`方法，那么线程A就会停止继续执行，转为等待状态。等待到何时结束呢？线程A会一直等到其他线程调用了`obj.notify()`方法为止。这时，object对象俨然成了多个线程之间的有效通信手段。

那么`wait()`方法和`notify()`方法究竟是如何工作的呢？图2.5展示了两者的工作过程。如果一个线程调用了`object.wait()`方法，那么它就会进入`object`对象的等待队列。这个等待队列中，可能会有多个线程，因为系统运行多个线程同时等待某一个对象。当`object.notify()`方法被调用时，它就会从这个等待队列中随机选择一个线程，并将其唤醒。这里希望大家注意的是，这个选择是不公平的，并不是先等待的线程就会优先被选择，这个选择完全是随机的

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center 5]  
除`notify()`方法外，Object对象还有一个类似的`notifyAll()`方法，它和`notify()`方法的功能基本一致，不同的是，它会唤醒在这个等待队列中所有等待的线程，而不是随机选择一个。

这里还需要强调一点，`Object.wait()`方法并不能随便调用。它必须包含在对应的`synchronzied`语句中，无论是`wait()`方法或者`notify()`方法都需要首先获得目标对象的一个监视器。图2.6显示了`wait()`方法和`notify()`方法的工作流程细节。其中T1和T2表示两个线程。T1在正确执行`wait()`方法前，必须获得object对象的监视器。而`wait()`方法在执行后，会释放这个监视器。这样做的目的是使其他等待在object对象上的线程不至于因为T1的休眠而全部无法正常执行。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center 6]  
线程T2在notify()方法调用前，也必须获得object对象的监视器。所幸，此时T1已经释放了这个监视器。因此，T2可以顺利获得object对象的监视器。接着，T2执行了notify()方法尝试唤醒一个等待线程，这里假设唤醒了T1。T1在被唤醒后，要做的第一件事并不是执行后续的代码，而是要尝试重新获得object对象的监视器，而这个监视器也正是T1在wait()方法执行前所持有的那个。如果暂时无法获得，则T1还必须等待这个监视器。当监视器顺利获得后，T1才可以在真正意义上继续执行。

public class SimpleWN { 
        final static Object object = new Object();
        public static class T1 extends Thread { 
            @Override
            public void run() { 
                synchronized (object) { 
                    System.out.println(System.currentTimeMillis() + " --> T1");
                    try { 
                        System.out.println(System.currentTimeMillis() + " --> T1 wait for object");
                        object.wait();
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                    System.out.println(System.currentTimeMillis() + " --> T1 end");
                }
            }
        }
    
        public static class T2 extends Thread { 
            @Override
            public void run() { 
                synchronized (object) { 
                    System.out.println(System.currentTimeMillis() + " --> T2");
                    object.notify();
                    System.out.println(System.currentTimeMillis() + " --> T2 end");
                    try { 
                        Thread.sleep(2000);
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                }
            }
        }
        public static void main(String[] args) { 
            Thread t1 = new T1();
            Thread t2 = new T2();
            t1.start();
            t2.start();
        }
    }

上述代码中，开启了T1和T2两个线程。T1执行了`object.wait()`方法。注意，在程序第6行，执行wait()方法前，T1先申请object的对象锁。因此，在执行`object.wait()`时，它是持有object的对象锁的。`wait()`方法执行后，T1会进行等待，并释放object的对象锁。  
T2在执行`notify()`方法之前也会先获得object的对象锁。这里为了让实验效果明显，特意安排在notify()方法执行之后，让T2休眠2秒，这样做可以更明显地说明，T1在得到`notify()`方法通知后，还是会先尝试重新获得object的对象锁。上述代码的执行结果类似如下：

![在这里插入图片描述][20201118202334146.png_pic_center]

注意程序打印的时间戳信息，在T2通知T1继续执行后，T1并不能立即继续执行，而是要等待T2释放object的锁，并重新成功获得锁后，才能继续执行。因此，加粗部分时间戳的间隔为2秒（因为T2休眠了2秒）。

注意：`Object.wait()`方法和`Thread.sleep()`方法都可以让线程等待若干时间。除`wait()`方法可以被唤醒外，另外一个主要区别就是`wait()`方法会释放目标对象的锁，而`Thread.sleep()`方法不会释放任何资源。

## 五、挂起(suspend)和继续执行(resume)线程 ##

如果你阅读JDK有关Thread类的API文档，可能还会发现两个看起来非常有用的接口，即线程挂起（suspend）和继续执行（resume）。这两个操作是一对相反的操作，被挂起的线程，必须要等到`resume()`方法操作后，才能继续指定。乍看之下，这对操作就像`Thread.stop()`方法一样好用。但如果你仔细阅读文档说明，会发现它们也早已被标注为废弃方法，并不推荐使用。

不推荐使用`suspend()`方法去挂起线程是因为`suspend()`方法在导致线程暂停的同时，并不会释放任何锁资源。  
此时，其他任何线程想要访问被它占用的锁时，都会被牵连，导致无法正常继续运行（如图2.7所示）。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center 7]

直到对应的线程上进行了`resume()`方法操作，被挂起的线程才能继续，从而其他所有阻塞在相关锁上的线程也可以继续执行。

但是，如果`resume()`方法操作意外地在`suspend()`方法前就执行了，那么被挂起的线程可能很难有机会被继续执行。并且，更严重的是：它所占用的锁不会被释放，因此可能会导致整个系统工作不正常。而且，对于被挂起的线程，从它的线程状态上看，居然还是Runnable，这也会严重影响我们对系统当前状态的判断。

public class TestClass { 
        public static Object u = new Object();
        static ChangeObjectThread t1 = new ChangeObjectThread("t1");
        static ChangeObjectThread t2 = new ChangeObjectThread("t2");
    
        public static class ChangeObjectThread extends Thread { 
            public ChangeObjectThread(String name) { 
                super.setName(name);
            }
            @Override
            public void run() { 
                synchronized (u) { 
                    System.out.println("--> " + getName());
                    Thread.currentThread().suspend();
                }
            }
        }
        public static void main(String[] args) throws InterruptedException { 
            t1.start();
            Thread.sleep(100);
            t2.start();
            t1.resume();
            t2.resume();
            t1.join();
            t2.join();
        }
    }

执行上述代码，开启t1和t2两个线程。它们会在第12行通过对象锁u实现对临界区的访问。

线程t1和t2启动后，在主函数第22～23行中对其进行`resume()`方法操作，目的是让它们得以继续执行。接着，主函数等待着两个线程的结束。  
执行上述代码后，我们可能会得到以下输出：

![在这里插入图片描述][20201113221906899.png_pic_center]  
这表明两个线程先后进入了临界区，但是程序不会退出，而是会挂起。使用`jstack`命令打印系统的线程信息可以看到：

![在这里插入图片描述][20201113221931495.png_pic_center]  
这时我们需要注意，在当前系统中，线程t2其实是被挂起的，但是它的线程状态确实是RUNNABLE，这很有可能使我们误判当前系统的状态。同时，虽然主函数中已经调用了`resume()`方法，但是由于时间先后顺序的缘故，那个resume并没有生效！这就导致了线程t2被永远挂起，并且永远占用了对象u的锁。这对于系统来说极有可能是致命的。

如果需要一个比较可靠的`suspend()`方法，那么应该怎么办呢？回想一下上面提到的`wait()`方法和`notify()`方法，这也不是一件难事。  
下面的代码就给出了一个利用`wait()`方法和n`otify()`方法，在应用层面实现`suspend()`方法和`resume()`方法功能的例子。

public class TestClass { 
        public static Object u = new Object();
        public static class ChangeObjectThread extends Thread { 
            //volatile 强制线程每次读取该值都从“主内存”中取值
            volatile boolean suspendme = false;
    
            //挂起
            public void suspendMe() { 
                suspendme = true;
            }
    
            //继续执行
            public void resumeMe() { 
                suspendme = false;
                synchronized (this) { 
                    //唤醒等待进程
                    notify();
                }
            }
    
            @Override
            public void run() { 
                int i = 0;
                while (i < 5) { 
                    i++;
                    if (i == 3) { 
                        this.suspendMe();
                    }
                    synchronized (this) { 
                        while (suspendme) { 
                            try { 
                                wait();
                            } catch (InterruptedException e) { 
                                e.printStackTrace();
                            }
                        }
                    }
                    synchronized (u) { 
                        System.out.println("in ChangeObjectThread");
                    }
                    //线程的礼让，将一个线程的操作暂时让给其他线程去执行
                    Thread.yield();
                }
            }
        }
    
        public static class ReadObjectThread extends Thread { 
            @Override
            public void run() { 
                int i = 0;
                while (i < 5) { 
                    i++;
                    synchronized (u) { 
                        System.out.println("in ReadObjectThread");
                    }
                    Thread.yield();
                }
            }
        }
    
        public static void main(String[] args) throws InterruptedException { 
            ChangeObjectThread t1 = new ChangeObjectThread();
            ReadObjectThread t2 = new ReadObjectThread();
            t1.start();
            t2.start();
            Thread.sleep(1000);
            t1.suspendMe();
            System.out.println("suspend t1 2 sec");
            Thread.sleep(2000);
            System.out.println("resume t1");
            t1.resumeMe();
        }
    }

在代码第5行，用标记变量suspendme表示当前线程是否被挂起。同时，增加了suspendMe()和resumeMe()两个方法，分别用于挂起线程和继续执行线程。  
在代码第29～36行中，线程会先检查自己是否被挂起，如果是，则执行wait()方法进行等待。否则，则进行正常的处理。当线程继续执行时，resumeMe()方法被调用（代码第13～18行），线程t1得到一个继续执行的notify()方法通知，并且清除了挂起标记，从而得以正常执行。

## 六、等待线程结束（join）和谦让（yeild） ##

在很多情况下，线程之间的协作和人与人之间的协作非常类似。一种非常常见的合作方式就是分工合作。以我们非常熟悉的软件开发为例，在一个项目进行时，总是应该有几位号称是“需求分析师”的同事，先对系统的需求和功能点进行整理和总结，以书面形式给出一份需求说明或者类似的参考文档，然后，软件设计师、研发工程师才会一拥而上，进行软件开发。如果缺少需求分析师的工作输出，那么软件研发的难度可能会比较大。

### 1. join ###

因此，作为一名软件研发人员，总是喜欢等待需求分析师完成他应该完成的任务后，才愿意投身工作。简单地说，就是研发人员需要等待需求分析师完成他的工作，然后才能进行研发。将这个关系对应到多线程应用中，很多时候，一个线程的输入可能非常依赖于另外一个或者多个线程的输出，此时，这个线程就需要等待依赖线程执行完毕，才能继续执行。JDK提供了`join()`操作来实现这个功能。如下所示，显示了两个`join()`方法：

![在这里插入图片描述][20201114110844218.png_pic_center]  
第一个`join()`方法表示无限等待，它会一直阻塞当前线程，直到目标线程执行完毕。第二个方法给出了一个最大等待时间，如果超过给定时间目标线程还在执行，当前线程也会因为“等不及了”，而继续往下执行。

英文join的翻译，通常是加入的意思。这个意思在这里也非常贴切。因为一个线程要加入另外一个线程，最好的方法就是等着它一起走。

这里提供一个简单点的`join()`方法实例供大家参考：

public class TestClass { 
        public volatile static int i = 0;
        public static class AddThread extends Thread { 
            @Override
            public void run() { 
                for (i = 0; i < 10000000; i++) { 
                }
            }
        }
    
        public static void main(String[] args) throws InterruptedException { 
            AddThread at = new AddThread();
            at.start();
            at.join();
            System.out.println(i);
        }
    }

在主函数中，如果不使用join()方法等待AddThread，那么得到的i很可能是0或者一个非常小的数字。因为AddThread还没开始执行，i的值就已经被输出了。  
但在使用join()方法后，表示主线程愿意等待AddThread执行完毕，跟着AddThread一起往前走，故在join()方法返回时，AddThread已经执行完成，因此i总是10 000000。

有关join()方法，我还想再补充一点，join()方法的本质是让调用线程wait()方法在当前线程对象实例上

下面是JDK中join()方法实现的核心代码片段：

![在这里插入图片描述][20201114112313211.png_pic_center]  
可以看到，它让调用线程在当前线程对象上进行等待。当线程执行完成后，被等待的线程会在退出前调用`notifyAll()`方法通知所有的等待线程继续执行。

因此，值得注意的一点是：不要在应用程序中，在Thread对象实例上使用类似wait()方法或者notify()方法等，因为这很有可能会影响系统API的工作，或者被系统API所影响

### 2. yeild ###

另外一个比较有趣的方法是`Thread.yield()`，它的定义如下：

public static native void yield();

这是一个静态方法，一旦执行，它会使当前线程让出CPU。但要注意，让出CPU并不表示当前线程不执行了。当前线程在让出CPU后，还会进行CPU资源的争夺，但是是否能够再次被分配到就不一定了。因此，对`Thread.yield()`方法的调用就好像是在说：“我已经完成了一些最重要的工作了，我可以休息一下了，可以给其他线程一些工作机会啦！”

如果你觉得一个线程不那么重要，或者优先级非常低，而且又害怕它会占用太多的CPU资源，那么可以在适当的时候调用`Thread.yield()`方法，给予其他重要线程更多的工作机会。

[20201113210151910.png_pic_center]: /images/20221120/015ad763e045416d89e87fdda8fc7a60.png
[20201113210553283.png_pic_center]: /images/20221120/e2e62d5b0529421897b8121eba5fa85f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/1cc2ea68be2a4ab48d48eb59543071f7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/b0d693d3e53b4362af8b0d0f214dbf4b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221120/1d19ef7ae2e14bc3bcc25813b4fb5065.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221120/5347d0ea5f5d4edb9d53b6acea5f561b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221120/18a5880fc32542968b73acf8ccb03387.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70]: /images/20221120/e13ec8d2d3704405b79a92486a504ae5.png
[20201113214252886.png_pic_center]: /images/20221120/b445a0481f0f4d1aa9be32165e07a7ff.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221120/53f82d4230794e72b542be4b5bcfd487.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221120/47b4315cb3934a3a9ab61d53de7129f6.png
[20201118202334146.png_pic_center]: /images/20221120/eadbb80c1075497ea719d12a092fe26e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221120/4d886c09558e4a5e974e11230558becd.png
[20201113221906899.png_pic_center]: /images/20221120/5e8964f588864451a5361d7857ca7739.png
[20201113221931495.png_pic_center]: /images/20221120/ffab8242246a4595929c6c0cd96ca49c.png
[20201114110844218.png_pic_center]: /images/20221120/7ffb118347ac4a3e88dade59edda20ba.png
[20201114112313211.png_pic_center]: /images/20221120/8d580d45894441b896f016341d608ed6.png