精华内容
下载资源
问答
  • 线程创建我们知道在Java里线程是通过java.lang.Thread类来实现。一般我们创建无返回值线程...这里就会引出两个经典面试题:为什么线程启动是调用start方法启动线程而不能直接调用run方法?如果多次调用sta...

    93963ff4beae26ed02a80941cee9e1fd.png

    线程的创建

    我们知道在Java里线程是通过java.lang.Thread类来实现的。一般我们创建无返回值的线程会用下面两个方法:

    1. 继承Thread类,重写run()方法;
    2. 实现Runnable接口,重写run()方法;

    线程启动会通过调用start方法来启动线程而不能直接调用run方法。

    这里就会引出两个经典的面试题:

    为什么线程启动是调用start方法来启动线程而不能直接调用run方法?
    如果多次调用start方法会发生什么?

    其实答案就是源码里,在这之前我们要了解线程的状态有哪些。

    Java架构度寒冬zhuanlan.zhihu.com
    a5a64a56636cdc130163e17d5a49bab0.png
    需要更多Java面试资料和学习干货可以关注我,我的专栏【Java架构度寒冬】,本专栏会长期更新java架构技术以及心得等精彩文章

    线程的状态

    线程从创建到死亡是会经历多个状态的流转的。它们分别是:NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED。

    59ebdde60fb74c90dcd9eefd5a93052f.png

    Java-Thread-Status

    // Thread类的内部的枚举类定义了线程的状态
    public enum State {
        NEW,
        RUNNABLE,
        BLOCKED,
        WAITING,
        TIMED_WAITING,
        TERMINATED;
    }

    start() 方法 & run()方法

    为什么线程启动是调用start方法来启动线程而不能直接调用run方法?

    从上图中,我们就可以看到,在New了一个线程后,首先进入初始态,然后调用start()方法来到就绪态,这里并不会立即执行线程里的任务,而是会等待系统资源分配,当分配到时间片后就可以开始运行了。 start()方法是一个native方法,它将启动一个新线程,并执行run()方法,这是真正的多线程工作。 而直接执行 run() 方法,会把 run 方法当成一个 main 线程下的普通方法去执行,并不会在某个线程中执行它,所以这并不是多线程工作。这就是为什么调用 start() 方法时会执行 run() 方法,为什么不能直接调用 run() 方法的原因了。

    Example:

    public class ThreadDemo    
      public static void main(String[] args) {
            Thread t1 = new Thread(new Task1());
            Thread t2 = new Thread(new Task2());
    
         // 测试1
            t1.start();
            t2.start();
    
         // 测试2
            t1.run();
            t2.run();
    
        }
    }
    
    class Task1 implements Runnable {
    
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println("Task1: " + i);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    class Task2 implements Runnable {
    
        @Override
        public void run() {
            for (int i = 10; i > 0; i--) {
                System.out.println("Task2: " + i);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    
    // 测试1输出
    Task1: 0
    Task2: 10
    Task1: 1
    Task2: 9
    Task1: 2
    Task2: 8
    Task1: 3
    Task2: 7
    Task1: 4
    Task2: 6
    Task1: 5
    Task2: 5
    Task1: 6
    Task2: 4
    Task1: 7
    Task2: 3
    Task1: 8
    Task2: 2
    Task1: 9
    Task2: 1
    我们可以看到Task1 和 Task2是交替打印的,是多线程在运行。
    // 测试2输出
    Task1: 0
    Task1: 1
    Task1: 2
    Task1: 3
    Task1: 4
    Task1: 5
    Task1: 6
    Task1: 7
    Task1: 8
    Task1: 9
    Task2: 10
    Task2: 9
    Task2: 8
    Task2: 7
    Task2: 6
    Task2: 5
    Task2: 4
    Task2: 3
    Task2: 2
    Task2: 1
    这个的输出是串行的,Task1 执行完才执行 Task2,所以不是多线程,是普通方法。

    如果多次调用start方法会发生什么?

    首先我们先测试一下。

    Example:

    public class ThreadDemo    
      public static void main(String[] args) {
            Thread t1 = new Thread(new Task1());
            Thread t2 = new Thread(new Task2());
    
         // 测试3
            t1.start();
            t1.start();
        }
    }
    
    // 测试3输出
    Task1: 0
    Task...
    Exception in thread "main" java.lang.IllegalThreadStateException
     at java.lang.Thread.start(Thread.java:708)
    Task...

    只有第一次成功执行,后面就抛出了异常
    java.lang.IllegalThreadStateException,让我们来从下面的源码里看看吧,在start方法进来后就会判断线程的状态,如果不是初始态状态就会抛出异常,所以第二次执行就会报错,因为线程的状态已经发生改变。

    源码

    start()方法源码:

    public synchronized void start() {  
            // 如果线程不是"NEW状态",则抛出异常!  
            if (threadStatus != 0)  
                throw new IllegalThreadStateException();  
            // 将线程添加到ThreadGroup中  
            group.add(this);  
            boolean started = false;  
            try {  
                // 通过start0()启动线程,新线程会调用run()方法  
                start0();  
                // 设置started标记=true  
                started = true;  
            } finally {  
                try {  
                    if (!started) {  
                        group.threadStartFailed(this);  
                    }  
                } catch (Throwable ignore) {  
                }  
            }  
        }

    run方法源码:

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

    总结

    • start()方法是用来启动线程,真正实现了多线程运行。
    • run()方法是一个普通方法。
    • 调用start()方法后会先判断线程的状态是否为NEW,所以线程只能启动一次。
    作者:何小H
    原文链接:https://juejin.im/post/5ef70e685188252e332e946e
    展开全文
  • 线程创建我们知道在Java里线程是通过java.lang.Thread类来实现。一般我们创建无返回值线程...这里就会引出两个经典面试题:为什么线程启动是调用start方法启动线程而不能直接调用run方法?如果多次调用sta...

    aeaaac53ccdb7a04d922c87e4177c163.png

    线程的创建

    我们知道在Java里线程是通过java.lang.Thread类来实现的。一般我们创建无返回值的线程会用下面两个方法:

    1. 继承Thread类,重写run()方法;
    2. 实现Runnable接口,重写run()方法;

    线程启动会通过调用start方法来启动线程而不能直接调用run方法。

    这里就会引出两个经典的面试题:

    为什么线程启动是调用start方法来启动线程而不能直接调用run方法?
    如果多次调用start方法会发生什么?

    其实答案就是源码里,在这之前我们要了解线程的状态有哪些。

    Java架构度寒冬zhuanlan.zhihu.com
    f1ca0126fa5aa4b7a52b7cecb81bc96c.png
    需要更多Java面试资料和学习干货可以关注我,我的专栏【Java架构度寒冬】,本专栏会长期更新java架构技术以及心得等精彩文章

    线程的状态

    线程从创建到死亡是会经历多个状态的流转的。它们分别是:NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED。

    d7fd9fadfeb5defdef253b0bc30c9ced.png

    Java-Thread-Status

    // Thread类的内部的枚举类定义了线程的状态
    public enum State {
        NEW,
        RUNNABLE,
        BLOCKED,
        WAITING,
        TIMED_WAITING,
        TERMINATED;
    }

    start() 方法 & run()方法

    为什么线程启动是调用start方法来启动线程而不能直接调用run方法?

    从上图中,我们就可以看到,在New了一个线程后,首先进入初始态,然后调用start()方法来到就绪态,这里并不会立即执行线程里的任务,而是会等待系统资源分配,当分配到时间片后就可以开始运行了。 start()方法是一个native方法,它将启动一个新线程,并执行run()方法,这是真正的多线程工作。 而直接执行 run() 方法,会把 run 方法当成一个 main 线程下的普通方法去执行,并不会在某个线程中执行它,所以这并不是多线程工作。这就是为什么调用 start() 方法时会执行 run() 方法,为什么不能直接调用 run() 方法的原因了。

    Example:

    public class ThreadDemo    
      public static void main(String[] args) {
            Thread t1 = new Thread(new Task1());
            Thread t2 = new Thread(new Task2());
    
         // 测试1
            t1.start();
            t2.start();
    
         // 测试2
            t1.run();
            t2.run();
    
        }
    }
    
    class Task1 implements Runnable {
    
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println("Task1: " + i);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    class Task2 implements Runnable {
    
        @Override
        public void run() {
            for (int i = 10; i > 0; i--) {
                System.out.println("Task2: " + i);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    
    // 测试1输出
    Task1: 0
    Task2: 10
    Task1: 1
    Task2: 9
    Task1: 2
    Task2: 8
    Task1: 3
    Task2: 7
    Task1: 4
    Task2: 6
    Task1: 5
    Task2: 5
    Task1: 6
    Task2: 4
    Task1: 7
    Task2: 3
    Task1: 8
    Task2: 2
    Task1: 9
    Task2: 1
    我们可以看到Task1 和 Task2是交替打印的,是多线程在运行。
    // 测试2输出
    Task1: 0
    Task1: 1
    Task1: 2
    Task1: 3
    Task1: 4
    Task1: 5
    Task1: 6
    Task1: 7
    Task1: 8
    Task1: 9
    Task2: 10
    Task2: 9
    Task2: 8
    Task2: 7
    Task2: 6
    Task2: 5
    Task2: 4
    Task2: 3
    Task2: 2
    Task2: 1
    这个的输出是串行的,Task1 执行完才执行 Task2,所以不是多线程,是普通方法。

    如果多次调用start方法会发生什么?

    首先我们先测试一下。

    Example:

    public class ThreadDemo    
      public static void main(String[] args) {
            Thread t1 = new Thread(new Task1());
            Thread t2 = new Thread(new Task2());
    
         // 测试3
            t1.start();
            t1.start();
        }
    }
    
    // 测试3输出
    Task1: 0
    Task...
    Exception in thread "main" java.lang.IllegalThreadStateException
     at java.lang.Thread.start(Thread.java:708)
    Task...

    只有第一次成功执行,后面就抛出了异常
    java.lang.IllegalThreadStateException,让我们来从下面的源码里看看吧,在start方法进来后就会判断线程的状态,如果不是初始态状态就会抛出异常,所以第二次执行就会报错,因为线程的状态已经发生改变。

    源码

    start()方法源码:

    public synchronized void start() {  
            // 如果线程不是"NEW状态",则抛出异常!  
            if (threadStatus != 0)  
                throw new IllegalThreadStateException();  
            // 将线程添加到ThreadGroup中  
            group.add(this);  
            boolean started = false;  
            try {  
                // 通过start0()启动线程,新线程会调用run()方法  
                start0();  
                // 设置started标记=true  
                started = true;  
            } finally {  
                try {  
                    if (!started) {  
                        group.threadStartFailed(this);  
                    }  
                } catch (Throwable ignore) {  
                }  
            }  
        }

    run方法源码:

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

    总结

    • start()方法是用来启动线程,真正实现了多线程运行。
    • run()方法是一个普通方法。
    • 调用start()方法后会先判断线程的状态是否为NEW,所以线程只能启动一次。
    作者:何小H
    原文链接:https://juejin.im/post/5ef70e685188252e332e946e
    展开全文
  • 线程启动会通过调用start方法启动线程而不能直接调用run方法。 这里就会引出两个经典面试题: 为什么线程启动是调用start方法启动线程而不能直接调用run方法? 如果多次调用start方法会发生什么? 其实...

    线程的创建

    我们知道在Java里线程是通过java.lang.Thread类来实现的。一般我们创建无返回值的线程会用下面两个方法:

    1. 继承Thread类,重写run()方法;
    2. 实现Runnable接口,重写run()方法;

    线程启动会通过调用start方法来启动线程而不能直接调用run方法。

    这里就会引出两个经典的面试题:

    1. 为什么线程启动是调用start方法来启动线程而不能直接调用run方法?
    2. 如果多次调用start方法会发生什么?

    其实答案就是源码里,在这之前我们要了解线程的状态有哪些。

    线程的状态

    线程从创建到死亡是会经历多个状态的流转的。它们分别是:NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED

    Java-Thread-Status

    // Thread类的内部的枚举类定义了线程的状态
    public enum State {
        NEW,
        RUNNABLE,
        BLOCKED,
        WAITING,
        TIMED_WAITING,
        TERMINATED;
    }
    

    start() 方法 & run()方法

    为什么线程启动是调用start方法来启动线程而不能直接调用run方法?

    从上图中,我们就可以看到,在New了一个线程后,首先进入初始态,然后调用start()方法来到就绪态,这里并不会立即执行线程里的任务,而是会等待系统资源分配,当分配到时间片后就可以开始运行了。 start()方法是一个native方法,它将启动一个新线程,并执行run()方法,这是真正的多线程工作。 而直接执行 run() 方法,会把 run 方法当成一个 main 线程下的普通方法去执行,并不会在某个线程中执行它,所以这并不是多线程工作。这就是为什么调用 start() 方法时会执行 run() 方法,为什么不能直接调用 run() 方法的原因了。

    Example:

    public class ThreadDemo    
    		public static void main(String[] args) {
            Thread t1 = new Thread(new Task1());
            Thread t2 = new Thread(new Task2());
    
      			// 测试1
            t1.start();
            t2.start();
    
     				// 测试2
            t1.run();
            t2.run();
    
        }
    }
    
    class Task1 implements Runnable {
    
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println("Task1: " + i);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    class Task2 implements Runnable {
    
        @Override
        public void run() {
            for (int i = 10; i > 0; i--) {
                System.out.println("Task2: " + i);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    
    // 测试1输出
    Task1: 0
    Task2: 10
    Task1: 1
    Task2: 9
    Task1: 2
    Task2: 8
    Task1: 3
    Task2: 7
    Task1: 4
    Task2: 6
    Task1: 5
    Task2: 5
    Task1: 6
    Task2: 4
    Task1: 7
    Task2: 3
    Task1: 8
    Task2: 2
    Task1: 9
    Task2: 1
    我们可以看到Task1 和 Task2是交替打印的,是多线程在运行。
    // 测试2输出
    Task1: 0
    Task1: 1
    Task1: 2
    Task1: 3
    Task1: 4
    Task1: 5
    Task1: 6
    Task1: 7
    Task1: 8
    Task1: 9
    Task2: 10
    Task2: 9
    Task2: 8
    Task2: 7
    Task2: 6
    Task2: 5
    Task2: 4
    Task2: 3
    Task2: 2
    Task2: 1
    这个的输出是串行的,Task1 执行完才执行 Task2,所以不是多线程,是普通方法。
    

    如果多次调用start方法会发生什么?

    首先我们先测试一下。

    Example:

    public class ThreadDemo    
    		public static void main(String[] args) {
            Thread t1 = new Thread(new Task1());
            Thread t2 = new Thread(new Task2());
    
      			// 测试3
            t1.start();
            t1.start();
        }
    }
    
    // 测试3输出
    Task1: 0
    Task...
    Exception in thread "main" java.lang.IllegalThreadStateException
    	at java.lang.Thread.start(Thread.java:708)
    Task...
    

    只有第一次成功执行,后面就抛出了异常java.lang.IllegalThreadStateException,让我们来从下面的源码里看看吧,在start方法进来后就会判断线程的状态,如果不是初始态状态就会抛出异常,所以第二次执行就会报错,因为线程的状态已经发生改变。

    源码

    start()方法源码:

        public synchronized void start() {  
            // 如果线程不是"NEW状态",则抛出异常!  
            if (threadStatus != 0)  
                throw new IllegalThreadStateException();  
            // 将线程添加到ThreadGroup中  
            group.add(this);  
            boolean started = false;  
            try {  
                // 通过start0()启动线程,新线程会调用run()方法  
                start0();  
                // 设置started标记=true  
                started = true;  
            } finally {  
                try {  
                    if (!started) {  
                        group.threadStartFailed(this);  
                    }  
                } catch (Throwable ignore) {  
                }  
            }  
        }  
    

    run方法源码:

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

    总结

    start()方法是用来启动线程,真正实现了多线程运行。

    run()方法是一个普通方法。

    调用start()方法后会先判断线程的状态是否为NEW,所以线程只能启动一次。


    求关注、分享、在看!!! 你的支持是我创作最大的动力。

    展开全文
  • run方法运行结果 run()方法只是类一个普通方法,如果直接调用run()方法...用start方法启动线程,真正实现了多线程运行,这时无需等待run方法体中代码执行完毕而直接继续执行后续代码。通过调用Thread类...

    run方法运行结果

    run()方法只是类的一个普通方法,如果直接调用run()方法,程序中依然只有主线程这一个线程,其程序执行路径还是只有一条,还是要顺序执行,还是要等待run方法体执行完毕后才可继续执行下面的代码,这样就没有达到多线程的目的。

    start方法运行结果

    start()方法使该线程开始执行;Java 虚拟机调用该线程的 run 方法。

    用start方法来启动线程,真正实现了多线程运行,这时无需等待run方法体中的代码执行完毕而直接继续执行后续的代码。通过调用Thread类的 start()方法来启动一个线程,这时此线程处于就绪(可运行)状态,并没有运行,一旦得到cpu时间片,就开始执行run()方法,这里的run()方法 称为线程体,它包含了要执行的这个线程的内容,run方法运行结束,此线程随即终止。

    run方法和start方法的总结

    调用start方法是启动一个线程,而调用run方法只是thread类中的一个普通方法调用,还是在主线程里执行。

     

     

    展开全文
  • 启动线程 在 C++11 中启动一个线程是非常简单,你可以使用 std:thread 来创建一个线程实例,创建完会自动启动,只需要给它传递一个要执行函数指针即可,请看下面这个 Hello world 代码:   #include #...
  • 启动线程的方法

    2014-08-26 17:30:00
    线程的Tread对象上调用start()方法,而不是run()或者别的方法。 在调用Start方法之前,线程出于新状态中,新状态是指有一个Thread对象!但还没有一个真正的线程。 在调用start之后发生了一系列复杂的事情 启动...
  • 线程创建我们知道在Java里线程是通过java.lang.Thread类来实现。一般我们创建无返回值线程...这里就会引出两个经典面试题:为什么线程启动是调用start方法启动线程而不能直接调用run方法?如果多次调用sta...
  • 有时候项目需要去做一些初始化操作,那么不能在项目已经启动了去做操作,走定时任务,或者执行一些接口,或者mq,目前我感觉最好办法就是执行一个异步线程,或者启动一个线程池在项目启动的时候去执行这些业务逻辑,...
  • 1.通过start方法启动线程,是真正创建多线程,无需等待run方法里面代码块执行完成后再执行run方法后面代码块。此时start方法创建线程处于就绪状态,等到得到cpu时间片后就执行run方法里面代码块,run方法...
  • Thread.start()方法是通知“线程规划器”此线程已经准备就绪,等待调用线程对象run()方法,是异步的执行结果。 Thread.run()方法则是同步,并不交给“线程规划器”来处理,而是由调用此线程的线程直接调用线程的...
  • 另一种是直接从Thread继承,创建一个新的class,把线程执行的代码放到这个新的 class里。 将函数传递进Thread对象 复制代码 代码如下: ”’  Created on 2012-9-5    @author: walfred @module:
  • 线程执行同一方法问题

    千次阅读 2018-04-09 12:36:36
    前言当多个线程启动,访问一个实例中一个方法时,执行情况如何,是等待一个线程执行完成还是同时处理?数据又该如何处理?Java虚拟机运行时数据区组成由五个部分组成,分别是:方法区,堆,栈,本地方法栈,程序...
  • java有多线程的特点,所谓线程是就是线程的一部分,是程序调度和执行的单位,类似于当我们看视频时,声音、图像都是线程,通过多线程我们就可以同时欣赏有图有声音的视频了。 真正的多线程就是多核CPU处理任务,大...
  • 线程的启动:参考官方文档调用线程的start方法,通知jvm虚拟机去调用该线程的run方法,结果是两个线程并发的执行,一个是当前线程(调用start方法的线程),一个执行run方法的线程如示例:public class ThreadTest {...
  • 继承Thread类创建一个继承于Thread类的子类重写Thread类中的run():将此线程要执行的操作声明在run()创建Thread的子类的对象调用此对象的start():①启动线程 ②调用当前线程的run()方法注意:千万不要调用run方法,...
  • 启动线程的方式调用的方法

    千次阅读 2019-08-14 19:29:33
    启动线程的方式是调用如下哪一个方法(C) A.start B.do C.run D.sleep 当用start()开始一个线程后,线程就进入就绪状态,使线程所代表虚拟处理机处于可运行状态,这意味着它可以由JVM调度并执行。这并不意味着...
  • Java中启动线程有两种方式,继承Thread类以及实现接口Runnable,由于Java无法... start():通过该方法启动线程的同时也创建了一个线程,真正实现了多线程,这是无需等待run()方法代码执行完毕就可以直接执行下面
  • 在android中,当我们遇到有较长延时操作,如网络登陆、...启动线程主要有两种方法,一种是Thread、Handler手段,另一种是runOnUiThread。方法一:使用Thread、Handler手段代码如下: new Thread(new Runnable()...
  • 线程之间的执行是相互独立,哪一个线程优先执行取决于OS调度 线程的创建方式: 实现Runnable接口: 创建自定义类并实现runnable接口,且实现接口中run方法; 实例化自定义类; 将自定义类实例作为参数传...
  • 程序:是一组计算机能识别和执行的指令,运行于电子计算机上,满足人们某种需求的信息化工具。 进程:进程指正在运行的程序。确切的来说,当一个程序进入内存运行,即变成一个进程,进程是处于运行过程中的程序,...
  • 只有调用线程的start()方法才会启动线程 ,例如,下面的没有调用start()方法,而只是调用了run()方法,运行后打印的线程的名称是主线程的名称。 run方法与start方法的区别 1 java中多线程有两个常见的方法start方法...
  • Thread大家应该不会陌生,Java的线程,这次介绍下 Thread状态切换和方法,使用场景和特性。在介绍方法之前,我们先介绍下线程的状态是如何切换线程状态:线程共包括以下5种状态。1. 新建状态(New) : 线程对象...
  • run() 方法是直接执行 Runnable 对象 run() 方法,是 main 线程下一个普通线程,并不是多线程执行; 源码分析(Java8): /** * 使该线程开始执行;Java 虚拟机将调用此线程 <code>run</code> 方法...
  • Thead类中start()方法和run()方法区别 1,start()用来启动一个线程,当调用start()方法时,系统才会...2,run()方法是在本线程,只是线程一个函数,而不是多线程的。如果直接调用run(),其实就相当于是调用了一
  • 同一段代码可能被不同的线程执行, 因此当前线程是相对, Thread.currentThread()方法的返回值是在代码实际运行时候线程对象 SubThread1.java package com.dym.juc.threadmethod; /* * 定义线程类 * 分别在构
  • Java8多线程的启动方法

    千次阅读 2017-11-24 21:57:30
    一、进程与线程的区别 ...2.并发性:在引入线程的OS中,不仅进程间可以并发执行,一个进程多个线程之间也可以并发执行 3.拥有资源:进程是拥有资源基本单位,线程除了拥有一点运行中必不可少资源(线程控制块,
  • 一、进程与线程的区别总:操作系统执行多任务,每个任务就是进程;进程执行多任务,每个任务就是线程;包含关系分:1.调度性:在引入线程的OS中,把线程作为调度和分派基本单位,把进程作为资源拥有基本单位2....
  • start()用来启动一个线程,当调用start()方法时,系统才会开启一个线程,通过Thead类中start()方法启动的线程处于就绪状态(可运行状态),此时并没有运行,一旦得到CPU时间片,就自动开始执行run()方法。...
  • 为什么调用的是start()方法执行的确实run()方法呢? ​ 如果想要弄清楚这个问题,最好的做法就是查看一下start()方法的实现操作,可以直接通过源代码观察。 public abstract void run(); //Runnable接口中的run()...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,857
精华内容 2,342
关键字:

启动线程执行的方法是