精华内容
下载资源
问答
  • 绍Java如何中断一个正在运行线程
  • 如何中断当前线程

    千次阅读 2017-12-29 22:38:08
    如何中断当前线程 中断当前线程有两种方式。第一种方式是通过调用线程的stop()方法,第二种方式通过调用interrupt()方法。  由于第一种方式是不安全的,所以本篇文章不做讨论,主要分享一下如何使用interrupt()...

    如何中断当前线程

    中断当前线程有两种方式。第一种方式是通过调用线程的stop()方法,第二种方式通过调用interrupt()方法。 
    由于第一种方式是不安全的,所以本篇文章不做讨论,主要分享一下如何使用interrupt()方法来中断线程。

    采用interrupt中止线程

    Thread类中提供了三个中断线程的方法,如下图: 
    这里写图片描述
    这里写图片描述
    方法详情: 
    - interrupt():中断当前线程。该方法仅设置当前线程的状态为中断,实际上并不中断线程的运行。如果要中断线程的运行,还需要当前线程自己中断 
    - interrupted():测试当前线程的状态是否被中断。使用这个方法会清除当前线程的状态。简言之,如果这个方法被调用了两次,那么第二次会返回false. 除非当前线程在第二次调用之前,第一次清除线程状态之后,再次再中断。 
    - isInterrupted():测试当前线程的状态是否被中断。这个方法与interrupted()这个方法最大的差异是isInterrupted()方法不会清除当前线程的状态。

    代码示例

    public class ThreadInterruptDemo implements Runnable {
    
        @Override
        public void run() {
    
    //        System.out.println("第一次调用Thread.interrupted()" + Thread.interrupted());
    //        System.out.println("第二次调用Thread.interrupted()" + Thread.interrupted());
    
            /**
             * isInterrupted()
             * 用来测试当前线程的运行状态
             * true:表示当前线程为中断状态
             * false:表示当前线程为运行状态
             * 可以通过这样的方法来中断线程运行
             */
            if (Thread.currentThread().isInterrupted()){
                System.out.println("由于线程状态是中断,所以return不再执行线程任务");
                return;
            }
    
            while (true) {
                try {
                    Thread.sleep(3L);
                    System.out.println("线程正在执行");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    break;
                }
            }
    
        }
    
        public static void main(String[] args) {
            Thread thread = new Thread(new ThreadInterruptDemo(), "ThreadInterruptDemo");
            // 开启线程
            thread.start();
    
            /**
             * 中断当前线程
             * 该方法仅设置当前线程的状态为中断,实际上并不中断线程的运行
             * 如果要中断线程的运行,还需要当前线程自己中断
             */
            thread.interrupt();
        }
    
    }
       
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46

    源代码链接: 
    https://github.com/myNameIssls/javase-study/blob/master/javase-multithreading/src/main/java/cn/tyrone/javase/thread/ThreadInterruptDemo.java 
    参考链接: 
    https://docs.oracle.com/javase/8/docs/api/ 
    https://www.cnblogs.com/w-wfy/p/6414801.html 
    http://blog.csdn.net/paincupid/article/details/47626819

    展开全文
  • 今天我们来一起聊一个问题: “被中断线程运行状态发生了什么变化” Java中的中断并不是说会把正在运行线程终止,而是仅仅设置下线程中断标志,列如下面的代码: package JavaDemo; /** * @program: Java...

    今天我们来一起聊一个问题: “被中断的线程,运行状态发生了什么变化”
    Java中的中断并不是说会把正在运行的线程终止,而是仅仅设置下线程的中断标志,列如下面的代码:

    package JavaDemo;
    
    /**
     * @program: JavaDemo
     * @description:
     * @author: 码上Java
     * @create: 2019-05-25 16:39
     */
    public class Main {
    
        private static final String THREAD_NUM="biz-thread";
        
        public static void main(String[] args) throws InterruptedException {
            //创建线程,内部任务是死循环
            Thread thread=new Thread(new Runnable() {
                @Override
                public void run() {
                    for (;;){
                        System.out.println("I am a sub thread");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            //不捕获该异常
                        }
                    }
                }
            },THREAD_NUM);
            //启动
            thread.start();
            //用户线程休眠3s
            Thread.sleep(3000);
    
            //中断子线程
            System.out.println("--begin interrupt sub thread--");
            thread.interrupt();
            System.out.println("--end   interrupt sub thread--");
    
        }
    
    }
    

    如上代码运行情况如下图所示:
    在这里插入图片描述如上代码创建了一个子线程启动,子线程间隔1s打印输出,main函数所在线程休眠3s后,调用子线程的interrupt方法中断子线程,可知子线程被中断后继续间隔1s打印一句,这说明设置线程中断标志并不会改变线程的运行状态,更不会打断线程的执行。
    Thread类中关于中断的方法有三个:

    void interrupt()方法:中断线程,仅仅设置线程的中断标志位true并立即返回,线程的运行状态并不会发生变化。
    源码如下:

     public void interrupt() {
            if (this != Thread.currentThread())
                checkAccess();
    
            synchronized (blockerLock) {
                Interruptible b = blocker;
                if (b != null) {
                    interrupt0();           // Just to set the interrupt flag
                    b.interrupt(this);
                    return;
                }
            }
            interrupt0();
        }
    

    boolean isInterrupted() :检测当前线程是否被中断,如果是返回true,否则返回false。
    源码如下:

    public boolean isInterrupted() {
             //传递false,说明不清除中断标志
            return isInterrupted(false);
        }
    

    boolean interrupted() :检测当前线程是否被中断,如果是返回true,否则返回false。与isInterrupted不同的是,该方法发现当前线程被中断后会清除中断标志。
    源码如下:

    private native boolean isInterrupted(boolean ClearInterrupted);
    

    需要注意的是,当一个线程处于休眠的时候,如果其他线程中断了它,则处于休眠的线程会抛出java.lang.InterruptedException异常而返回:

    public class Main {
    
        private static final String THREAD_NUM="biz-thread";
    
        public static void main(String[] args) throws InterruptedException {
            //创建线程
            Thread thread=new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("I am a sub thread");
                    try {
                        Thread.sleep(10000000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("--I am interrupted--");
                }
            },THREAD_NUM);
            //启动
            thread.start();
            //用户线程休眠3s
            Thread.sleep(3000);
    
            //中断子线程
            System.out.println("--begin interrupt sub thread--");
            thread.interrupt();
            System.out.println("--end   interrupt sub thread--");
    
        }
    
    }
    

    如上代码运行情况如下图所示:
    在这里插入图片描述
    以上代码中,子线程调用了Thread.shleep(10000000);,表示自己休眠10000s,在没其他线程干扰的情况下,子线程需要等10000s后才会从sleep返回,但是这里main函数所在线程休眠3s后中断了子线程,这时候子线程从sleep处抛出java.lang.InterruptedException异常后返回了。

    Java中的线程中断只是简单设置中断标志,至于剩下的事情就需要我们自己来做,比如根据中断标志来判断是否退出执行。

    下面看一下线程使用Interrupted优雅退出的经典例子,代码如下:

      //创建线程
            Thread thread=new Thread(new Runnable() {
                @Override
                public void run() {
                   
                    //如果当前线程被中断则退出循环
                    while (!Thread.currentThread().isInterrupted())
                        System.out.println(Thread.currentThread()+"Hello");
                }
            });
    
    展开全文
  • 当一个优先级高的线程进入就绪状态时,当前线程执行时,如果是抢占式的调度方式,是会暂停当前线程的执行的,当仍然不是终止它的执行。当不是抢占式的调度时,高优先级的线程将在当前线程终止后,得到优先的执行权。...

    在这里插入图片描述
    当一个优先级高的线程进入就绪状态时,当前线程执行时,如果是抢占式的调度方式,是会暂停当前线程的执行的,当仍然不是终止它的执行。当不是抢占式的调度时,高优先级的线程将在当前线程终止后,得到优先的执行权。
    调用sleep方法,当前线程j进入阻塞状态,sleep执行完成后重新进入就入就绪状态

    线程结束的三个原因: 1、run方法执行完成,线程正常结束 2、线程抛出一个未捕获的Exception或者Error 3、直接调用该线程的Stop方法结束线程(不建议使用,容易导致死锁)

    当创建一个新的线程时,该线程也加入到了抢占cpu执行权的队伍中,但是是否能抢到,并不清楚
    在这里插入图片描述
    父类没有无参构造函数,z子类需要显示调用父类的有参构造函数,super(形参);
    子类第一行都有默认的super( );
    在这里插入图片描述
    1)此处是类对方法的调用,不是对象对方法的调用。
    2)方法是static静态方法,直接使用"类.方法"即可,因为静态方法使用不依赖对象是否被创建。
    null可以被强制类型转换成任意类型(不是任意类型对象),于是可以通过它来执行静态方法。
    3)非静态的方法用"对象.方法"的方式,必须依赖对象被创建后才能使用,若将testMethod()方法前的static去掉,则会报 空指针异常 。此处也验证了2)的观点
    在这里插入图片描述
    本题是一个自动拆装箱的考题(自动拆装箱JDK需在1.5上),下面的讨论都不针对新开辟对象的情况:
    1、基本型和基本型封装型进行“”运算符的比较,基本型封装型将会自动拆箱变为基本型后再进行比较,因此Integer(0)会自动拆箱为int类型再进行比较,显然返回true;
    2.Integer的
    比较应该与其声明方式与值范围有关.像Integer a = new Integer(3),这样声明的两个Integer对象==比较返回的应该是false.因为堆中指向不同的地址值.但是像用Integer b = 3这样声明的,只要在-128127的范围内时==比较返回的是true,这是因为在方法去存在一个数组,存储着-128127的数,这时b的值是直接指向方法区的地址值.
    3、两个基本型的封装型进行equals()比较,首先equals()会比较类型,如果类型相同,则继续比较值,如果值也相同,返回true
    4、基本型封装类型调用equals(),但是参数是基本类型,这时候,先会进行自动装箱,基本型转换为其封装类型,再进行3中的比较。

    展开全文
  • 线程中断机制

    万次阅读 多人点赞 2017-08-18 12:02:55
    在 java中启动线程非常容易,大多数情况下是让一个线程执行完自己的任务然后自己停掉... 在当前的api中,Thread.suspend、Thread.stop等方法都被Deprecated了,线程只能用interrupt中断,而且不是立刻中断,只是发了一

    友情推荐:

    1. 线程池原理
    2. 深入Thread.sleep
    3. head first Thread.join()

    在 java中启动线程非常容易,大多数情况下是让一个线程执行完自己的任务然后自己停掉。一个线程在未正常结束之前, 被强制终止是很危险的事情. 因为它可能带来完全预料不到的严重后果,比如会带着自己所持有的锁而永远的休眠,迟迟不归还锁等。在当前的api中,Thread.suspend、Thread.stop等方法都被Deprecated了,线程只能用interrupt中断,而且不是立刻中断,只是发了一个类似于信号量的东西,通过修改了被调用线程的中断状态来告知那个线程, 说它被中断了,至于什么时候中断,这个有系统判断,会在一个合适的时候进行中断处理。

    /**
     * Created by Zero on 2017/8/17.
     */
    public class ThreadTest1 {
        public static void main(String[] args) {
            NThread nThread = new NThread();
            System.out.println("interrupt执行前");
            nThread.start();
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            nThread.interrupt();
            System.out.println("interrupt执行后");
        }
    
        /**
         * 测试多线程的中断机制
         */
        static class NThread extends Thread{
            @Override
            public void run() {
                super.run();
                while(true){
                    System.out.println("依然存活...");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    这里写图片描述

    在上面代码中,线程睡醒之后,调用thread线程的interrupt方法,catch到InteruptedException,设置标志位。interrupt()方法相当于线程睡着的时候一盆凉水来吵醒它,线程表示不开心,并向你抛出一个大大的异常以示不满。

    这里写图片描述

    • 首先:线程中断是一种协作机制,调用线程对象的interrupt方法并不一定就中断了正在运行的线程,它只是要求线程自己在合适的时间中断自己。
    • 其次:任务的方法必须是可中断的,即方法必须抛出InterruptedException。

    由此可见,interrupt() 方法并不能立即中断线程,该方法仅仅告诉线程外部已经有中断请求,至于是否中断还取决于线程自己。在Thread类中除了interrupt() 方法还有另外两个非常相似的方法:interrupted 和 isInterrupted 方法,下面来对这几个方法进行说明:

    • interrupt 此方法是实例方法,用于告诉此线程外部有中断请求,并且将线程中的中断标记设置为true,而不是立即中断。
    • interrupted 此方法是类方法,用来判断当前线程是否已经中断。线程的中断状态由该方法清除。
    • isInterrupted 此方法是实例方法,用来判断线程是否已经中断。线程的中断状态不受该方法的影响。

    总结:java线程中断机制通过调用Thread.interrupt() 方法来做的,这个方法通过修改了被调用线程的中断状态来告知那个线程说它被中断了。对于非阻塞中的线程,只是改变了中断状态,即Thread.isInterrupted() 将返回true;对于可取消的阻塞状态中的线程,比如等待在这些函数上的线程,Thread.sleep()、Object.wait()、Thread.join(), 这个线程收到中断信号后,会抛出InterruptedException,同时会把中断状态置回为true。但调用Thread.interrupted()会对中断状态进行复位。

    /**
     * Created by Zero on 2017/8/17.
     */
    public class ThreadTest1 {
        public static void main(String[] args) {
            NThread nThread = new NThread();
            nThread.start();
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("cancel执行前" + System.currentTimeMillis());
            nThread.cancel();
        }
    
        /**
         * 测试多线程的中断机制
         */
        static class NThread extends Thread {
    
            private boolean isCancel;
    
            @Override
            public void run() {
                while (!isCancel) {
                    System.out.println("依然存活...");
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        Thread.currentThread().interrupt();
                    }
                }
                System.out.println("while结束" + System.currentTimeMillis());
            }
    
            public void cancel() {
                this.isCancel = true;
            }
        }
    }

    执行结果:

    依然存活...
    cancel执行前1502964413042
    while结束1502964415042

    机智的你,此刻一定发现执行前后相差2000毫秒,难道cancel()方法执行了2000毫秒?这纯属扯淡,里面没有任何耗时操作,就是一个赋值而已,其实是子线程的退出,前提条件是while循环结束,当且仅当cancel标示设置为true的瞬间立马执行while的判断,此时的时间差才可以忽略不计(1毫秒内),但是当我们调用cancel方法将isCancel 标记设置为true 时,while循环里面有一个耗时操作(休眠5000毫秒),只有等待耗时操作执行完毕后才会去检查这个标记,所以cancel方法和线程退出中间有时间间隔。

    接下来,我们通过interrupt 和 isinterrupt 方法来中断线程,代码如下:

    /**
     * Created by Zero on 2017/8/17.
     */
    public class ThreadTest1 {
        public static void main(String[] args) {
            NThread nThread = new NThread();
            nThread.start();
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("interrupt执行前"+System.currentTimeMillis());
            nThread.interrupt();
        }
    
        /**
         * 测试多线程的中断机制
         */
        static class NThread extends Thread{
    
            @Override
            public void run() {
                while(!interrupted()){
                    System.out.println("依然存活...");
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        System.out.println("InterruptedException");
                        Thread.currentThread().interrupt();
                    }
                }
                System.out.println("interrupt执行后"+System.currentTimeMillis());
            }
        }
    }
    
    依然存活...
    interrupt执行前1502965915683
    InterruptedException
    interrupt执行后1502965915683

    这次立马中断了,是因为在开启子线程后,经过执行3000毫秒的休眠,线程执行了interrupt 方法,此时子线程的5000毫秒休眠还没结束,就像上述所说的睡眠中被一盆冷水吵醒,很不开心的抛了异常,Thread.currentThread().interrupt() 改变了线程的标记状态,在抛出InterruptedException 的同时,线程的中断标志被清除了,再次执行while循环语句的时候,!interrupted() 此时是false,便不再执行while语句。

    此处如果去掉Thread.currentThread().interrupt() ,线程便会无休止的执行下去,此处就不上代码了,就注释掉这一行,运行就可以看到效果,经常看到一些代码在catch中不作任何处理,其实有时候这样是很危险的,此处已经证明。

    两点建议:
    1. 除非你知道线程的中断策略,否则不应该中断它。
    2. 任务代码不该猜测中断对执行线程的含义。遇到InterruptedException异常时,不应该将其捕获后“吞掉”,而应该继续向上层代码抛出。

    微信扫我,^_^

    展开全文
  • 获取当前正在运行的所有线程

    千次阅读 2018-08-31 14:49:44
    private Thread[] findAllThreads() { ThreadGroup group = Thread.currentThread().getThreadGroup(); ThreadGroup topGroup = group;... /* 遍历线程组树,获取根线程组 */ while (group != null) { t...
  • 线程面试题(值得收藏)

    万次阅读 多人点赞 2019-08-16 09:41:18
    史上最强多线程面试47题(含答案),建议收藏 金九银十快到了,即将进入找工作的高峰期,最新整理的最全多线程并发面试47题和答案总结,希望对想进BAT的同学有帮助,由于篇幅较长,建议收藏后细看~ 1、并发编程三要素?...
  • 本文实例讲述了Android中断线程的处理方法。分享给大家供大家参考。具体方法如下: 我现在对一个用户注册的功能 1.用ProgressDialog将当前页面设成不可操作(保留返回键 退出ProgressDialog) 2.用一个线程...
  • 线程的停止和中断

    千次阅读 2019-04-22 13:01:25
    4.interrupt方法中断线程, 需要主动编码配合,写中断逻辑,但是可控。 调用interrupt()方法只是打了个退出标志,并非真正的退出,退出逻辑需要自己写。 package ThreadCheat1.interrupt; /**...
  • 线程中断详解

    万次阅读 多人点赞 2018-07-05 19:01:44
    中断线程线程的thread.interrupt()方法是中断线程,将会设置该线程中断状态位,即设置为true,中断的结果线程是死亡、还是等待新的任务或是继续运行至下一步,就取决于这个程序本身。线程会不时地检测这个中断标示...
  • 介绍 这篇文章主要记录使用 interrupt() 方法中断线程,以及如何对InterruptedException进行处理。感觉对InterruptedException...由于使用stop()方法停止线程非常的暴力,人家线程运行的好好的,突然就把人家杀死...
  • 线程——2如何正确的中断线程

    千次阅读 2019-11-02 10:28:33
    线程探险——2常用方法 一、内容安排 什么是守护线程(Daemon Thread) Join方法的含义 自己join自己会是什么效果 Interrupt方法 综合案列:如何去停止线程 二、文章内容 1. 什么...
  • Java的interrupt中断线程详解

    千次阅读 2020-03-17 22:58:22
    主要讲解Java interrupt线程中断,以及停止线程的方式,并且进行了相关的代码演示。
  •     进程:系统中能独立运行并作为资源分配的基本单位,是一个独立运行的活动实体 ...Java 线程运行的生命周期中可能有6种不同的状态,在某个时刻,线程只能处于其中的一个.
  • 使用interrupt方法中断线程

    千次阅读 2017-09-03 23:54:54
    Thread类的interrupt方法是用来中断一个线程的。
  • 线程中实现不可中断的任务

    千次阅读 2018-05-27 18:34:34
    它并不会真正地中断一个正在运行线程,而只是发出中断请求,然后由线程在下一个合适的时刻中断自己。 调用interrupt并不意味着立即停止目标线程正在进行的工作,而只是传递了请求中断的消息。 public class...
  • 中断线程调度时机

    千次阅读 2018-04-03 09:47:15
    Linux内核中softirq、tasklet、线程的调度时机softirq、tasklet tasklet是通过softirq执行的,所以归为一类,不过softirq可以在多个核上同时执行,tasklet只能在一个核上运行。softirq通常会在中断执行结束后判断...
  • 调试器(如VS2008和老版GDB)往往只支持all-stop模式,调试多线程程序时,如果某个线程断在一个断点上,你的调试器会让整个程序freeze,直到你continue这个线程,程序中的其他线程才会继续运行。这个限制使得被调试...
  • 线程中断到底是什么

    千次阅读 2020-03-27 09:28:41
    我们如何让线程安全的停止呢? 1. 线程自然终止 自然执行完或抛出未处理异常。 2. stop(),resume(),suspend()方法 stop(),resume(),suspend()已不建议使用,stop()会导致线程不会正确释放资源,suspend()容易导致...
  • http://blog.csdn.net/ssssssue 停止线程 测试interrupt中断线程 测试interrupt中断线程 public class Demo { public static void main(String[] args) { StopRunnable stopRunnable = new Stop
  • 线程中断可以使一个线程从等待状态变成就绪状态,如果中断线程正处于运行状态,那么这个中断是不会用任何作用的(表面上不会影响正在运行线程),线程恢复到就绪状态后,可以继续执行逻辑代码,想要让一个线程...
  • 最近在Review线程专栏,修改了诸多之前描述不够严谨的地方,凡是带有Review标记的文章都是修改过了。本篇文章是插进来的,因为原来没有写,现在来看传统线程描述的不太完整,所以就补上了。理解了线程同步和线程通信...
  • Java 线程阻塞、中断及优雅退出

    万次阅读 2017-06-12 19:54:17
    线程阻塞一个线程进入阻塞状态的原因可能如下(已排除Deprecated方法):sleep()sleep()使当前线程进入停滞状态(阻塞当前线程),让出CUP的使用、目的是不让当前线程独自霸占该进程所获的CPU资源,以留一定时间给...
  • 这篇学习关于Thread类的两个方法,第一个是获取当前线程对象,返回的是一个Thread对象。第二个方法是我们自动化中经常使用的,线程休眠。 1.currentThread() 获取的是当前线程对象,是对象不是对象名称,如果要...
  • 如何优雅的中断线程

    千次阅读 2019-08-22 22:15:18
    有时候我们需要中断一个线程。由于启动一个线程的方法是start(),所以终止一个线程很容易想到stop(),JDK在 java.lang.Thread类中确实提供了一个stop()方法,这个方法的作用是强制停止一个线程。但是从jdk1.2开始就...
  • Thread 线程的基本概念我们已经在深入理解Java并发机制(1)–理论基础中总结过了,这里不再赘述。 线程的状态 ... 运行态,将操作系统中的就绪态和运行态统一定义为RUNNABLE BLOCKED 阻塞态,线程等...
  • c++并发编程(七)—— 线程中断

    千次阅读 2019-02-26 10:52:14
    有些线程是作为长时间工作的,其运行函数内部都会有个无限循环,但是某些时候我们希望能够主动停止线程:如人为停止或某一条件满足后退出。 这里我们首先看看一个简单的思路:要想从一个线程终止另外一个线程,我们...
  • 一、使用interrupt()中断线程

    千次阅读 2018-04-17 21:37:44
    当一个线程运行时,另一个线程可以调用对应的Thread对象的interrupt()方法来中断它,该方法只是在目标线程中设置一个标志,表示它已经被中断,并立即返回。这里需要注意的是,如果只是单纯的调用interrupt()方法...
  • 如何停止一个正在运行线程

    千次阅读 2020-02-26 10:11:07
    停止一个线程意味着在任务处理完任务之前停掉正在做的操作,也就是放弃当前的操作。停止一个线程可以用Thread.stop()方法,但最好不要用它。虽然它确实可以停止一个正在运行线程,但是这个方法是不安全的,而且是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 164,457
精华内容 65,782
关键字:

中断当前线程的运行