精华内容
下载资源
问答
  • 先上结论:run只是Thread里面的一...可以执行下面的代码看看run和start的区别: package com.basic.thread; /** * @author zhangxingrui * @create 2019-02-16 20:12 **/ public class TestRunAndStar...

    先上结论:run只是Thread里面的一个普通方法,start是启动线程的方法。何以见得呢?可以执行下面的代码看看run和start的区别:

    package com.basic.thread;
    
    /**
     * @author zhangxingrui
     * @create 2019-02-16 20:12
     **/
    public class TestRunAndStart {
    
        private static void sayHello(){
            System.out.println("hello, world");
        }
    
        public static void main(String[] args) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    sayHello();
                    System.out.println("Current thread: " + Thread.currentThread().getName());
                }
            });
    
            thread.run();
            thread.start();
        }
    
    }

      执行结果:

      由此可以看到子线程是由start来启动的,里面调用了run,所以打印出来的是子线程的name。

      另外也可以从start方法的底层代码看到,首先进入start方法里面

    public synchronized void start() {
            /**
             * This method is not invoked for the main method thread or "system"
             * group threads created/set up by the VM. Any new functionality added
             * to this method in the future may have to also be added to the VM.
             *
             * 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 */
                }
            }
        }

      里面调用了start0,继续跟进

    private native void start0();

      哦,这里就调了native方法了,再往下我们就看不到了。但是可以去openjdk的源码里面去看一下,我用的是jdk8。

      去openjdk看源码

      https://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/f0b93fbd8cf8/src/share/native/java/lang/Thread.c

      

      这里调用了JVM_StartThread,在jvm.h里面

      继续进入

      https://hg.openjdk.java.net/jdk8u/jdk8u/hotspot/file/76a9c9cf14f1/src/share/vm/prims/jvm.cpp

      

      重点看最下面的语句native_thread = new JavaThread(&thread_entry, sz),好,new JavaThread的时候传入了thread_entry,我们再去

    看一下啊thread_entry是什么:

      

      在thread_entry这个函数里面调用call_virtual方法,重点是它传入的参数run_method_name,从这里我们就知道了,噢,

    原来start最终会在新线程里面调用run方法。

     

    转载于:https://www.cnblogs.com/alinainai/p/10389161.html

    展开全文
  • 先上结论:run只是Thread里面...可以执行下面的代码看看run和start的区别:packagecom.basic.thread;/***@authorzhangxingrui* @create 2019-02-16 20:12**/public classTestRunAndStart {private static voidsayHel...

    先上结论:run只是Thread里面的一个普通方法,start是启动线程的方法。何以见得呢?可以执行下面的代码看看run和start的区别:

    packagecom.basic.thread;/***@authorzhangxingrui

    * @create 2019-02-16 20:12

    **/

    public classTestRunAndStart {private static voidsayHello(){

    System.out.println("hello, world");

    }public static voidmain(String[] args) {

    Thread thread= new Thread(newRunnable() {

    @Overridepublic voidrun() {

    sayHello();

    System.out.println("Current thread: " +Thread.currentThread().getName());

    }

    });

    thread.run();

    thread.start();

    }

    }

    执行结果:

    5cbabe0a89023b82bf7aa7387b456895.png

    由此可以看到子线程是由start来启动的,里面调用了run,所以打印出来的是子线程的name。

    另外也可以从start方法的底层代码看到,首先进入start方法里面

    public synchronized voidstart() {/*** This method is not invoked for the main method thread or "system"

    * group threads created/set up by the VM. Any new functionality added

    * to this method in the future may have to also be added to the VM.

    *

    * A zero status value corresponds to state "NEW".*/

    if (threadStatus != 0)throw newIllegalThreadStateException();/*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*/}

    }

    }

    里面调用了start0,继续跟进

    private native void start0();

    哦,这里就调了native方法了,再往下我们就看不到了。但是可以去openjdk的源码里面去看一下,我用的是jdk8。

    去openjdk看源码

    1dd73636337810e3c7338101c1c4881c.png

    这里调用了JVM_StartThread,在jvm.h里面

    继续进入

    8f83217ddea2a837a3cc89688936add1.png

    重点看最下面的语句native_thread = new JavaThread(&thread_entry, sz),好,new JavaThread的时候传入了thread_entry,我们再去

    看一下啊thread_entry是什么:

    55dabbb9208e5e96af456f5d8c2255d1.png

    在thread_entry这个函数里面调用call_virtual方法,重点是它传入的参数run_method_name,从这里我们就知道了,噢,

    原来start最终会在新线程里面调用run方法。

    展开全文
  • start():通过该方法启动线程的同时也创建了一个线程,真正实现了多线程,这是无需等待run()方法中代码执行完毕就可以直接执行线程外面代码,通过start创建的线程处于可运行状态,当得到CPU时间片后就会执行其中...

    start():通过该方法启动线程的同时也创建了一个线程,真正实现了多线程,这是无需等待run()方法中的代码执行完毕就可以直接执行线程外面的代码,通过start创建的线程处于可运行状态,当得到CPU时间片后就会执行其中的run方法, 这里方法run()称为线程体,它包含了要执行的这个线程的内容,Run方法运行结束, 此线程随即终止。

    run():在当前线程开启,比如当前线程是主线程,那么运行在主线程,如果当前线程是子线程,那么在子线程运行。还是要顺序执行,还是要等待run方法体执行完毕后才可继续执行下面的代码,这样就没有达到写线程的目的。

    示范一:在主线程通过start方法开启线程

    new Thread(new Runnable() {

    @Override

    public void run() {//Thread-5878

    System.out.println("====本线程是通过start方式开启的,会单独开启一个线程==1==="+currentThread().getName());

    }

    }).start();

    示范二:在主线程通过run方法开启线程

    new Thread(new Runnable() {//Thread-main

    @Override

    public void run() {

    System.out.println("====本线程是通过在主线程中run方式开启的,并没有创建一个线程==2==="+currentThread().getName());

    }

    }).run();//run开启是在当前线程

    示范三:在子线程通过run方法开启新线程

    new Thread(new Runnable() {

    @Override

    public void run() {

    new Thread(new Runnable() {

    @Override

    public void run() {//run是在当前线程运行也就是外层的子线程 Thread-5880

    System.out.println("====本线程是通过在子线程中通过run方式开启的,并没有创建一个线程==3==="+currentThread().getName());

    }

    }).run();//run开启是在当前线程

    }

    }).start();

    上面三种方式,其执行顺序是:

    第一组数据:

    ====本线程是通过在主线程中run方式开启的,并没有创建一个线程==2===main

    ====本线程是通过在子线程中通过run方式开启的,并没有创建一个线程==3===Thread-5880

    ====本线程是通过start方式开启的,会单独开启一个线程==1===Thread-5878

    第二组数据:

    ====本线程是通过在主线程中run方式开启的,并没有创建一个线程==2===main

    ====本线程是通过start方式开启的,会单独开启一个线程==1===Thread-5882

    ====本线程是通过在子线程中通过run方式开启的,并没有创建一个线程==3===Thread-5884

    其中第二种运行在主线程,第一种和三种运行在子线程。二三执行的先后顺序不确定。

    展开全文
  • 真正实现了多线程,这是无需等待run()方法中代码执行完毕就可以直接执行线程外面代码,通过start创建的线程处于可运行状态,当得到CPU时间片后就会执行其中的run方法, 这里方法run()称为线程体,它包含了要...

    start():通过该方法启动线程的同时也创建了一个线程,真正实现了多线程,这是无需等待run()方法中的代码执行完毕就可以直接执行线程外面的代码,通过start创建的线程处于可运行状态,当得到CPU时间片后就会执行其中的run方法, 这里方法run()称为线程体,它包含了要执行的这个线程的内容,Run方法运行结束, 此线程随即终止。

    run():在当前线程开启,比如当前线程是主线程,那么运行在主线程,如果当前线程是子线程,那么在子线程运行。还是要顺序执行,还是要等待run方法体执行完毕后才可继续执行下面的代码,这样就没有达到写线程的目的。

    示范一:在主线程通过start方法开启线程

      new Thread(new Runnable() {
                    @Override
                    public void run() {//Thread-5878
                        System.out.println("====本线程是通过start方式开启的,会单独开启一个线程==1==="+currentThread().getName());
                    }
                }).start();

    示范二:在主线程通过run方法开启线程

      new Thread(new Runnable() {//Thread-main
                    @Override
                    public void run() {
                        System.out.println("====本线程是通过在主线程中run方式开启的,并没有创建一个线程==2==="+currentThread().getName());
                    }
                }).run();//run开启是在当前线程

    示范三:在子线程通过run方法开启新线程

    new Thread(new Runnable() {
                    @Override
                    public void run() {
                        new Thread(new Runnable() {
                            @Override
                            public void run() {//run是在当前线程运行也就是外层的子线程   Thread-5880
                                System.out.println("====本线程是通过在子线程中通过run方式开启的,并没有创建一个线程==3==="+currentThread().getName());
                            }
                        }).run();//run开启是在当前线程
                    }
                }).start();

    上面三种方式,其执行顺序是:

    第一组数据:
    ====本线程是通过在主线程中run方式开启的,并没有创建一个线程==2===main
    
    ====本线程是通过在子线程中通过run方式开启的,并没有创建一个线程==3===Thread-5880
    
    ====本线程是通过start方式开启的,会单独开启一个线程==1===Thread-5878
    
    
    第二组数据:
    ====本线程是通过在主线程中run方式开启的,并没有创建一个线程==2===main
    
    ====本线程是通过start方式开启的,会单独开启一个线程==1===Thread-5882
    
    ====本线程是通过在子线程中通过run方式开启的,并没有创建一个线程==3===Thread-5884

    其中第二种运行在主线程,第一种和三种运行在子线程。二三执行的先后顺序不确定。

    展开全文
  • public class ThreadTest {/*** 观察直接调用run()start()启动一个线程的差别** @param args* @throws Exception*/public static void main(String[] args){Thread thread=new ThreadDemo();//第一种//表明: run...
  • run只是Thread里面一个普通方法,start是启动...而 run 方法是业务逻辑实现地方, 本质上任意一个类任意一个成员方法并没有任何区别, 可以重复执行, 也可以被单独调用。1.start()方法来启动线程,无需等...
  • Java线程run和start方法的区别 Thread类中run()和start()方法的区别如下: run()方法:在本线程内调用该Runnable对象的run()方法,可以重复多次调用; start()方法:启动一个线程,调用该Runnable对象的run()方法,...
  • 然后通过此Thread类调用方法run()来完成其运行操作, 这里方法run()称为线程体, 它包含了要执行这个线程的内容, run方法运行结束, 此线程终止, 而CPU再运行其它线程,  直接用run方法: 这只是调用一个...
  • java线程run和start两种方法的区别: 1)start: 用start方法来启动线程,真正实现了多线程运行,这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的start()方法来启动一个线程,...
  • start方法:用于启动线程,可以实现多线程运行,无需等待run方法执行完毕后就可以继续执行下面代码。通过调用Thread类的start方法来启动一个线程,此时线程处于就绪状态,一旦CPU有空闲就可执行run方法,run方法...
  • java线程run和start方法的区别

    万次阅读 2018-01-24 09:05:36
    1 java中多线程有两个常见方法start方法和run方法。正常来说run方法是多线程的线程体。 2 创建线程,可以使用extends Threadimplements Runnable 如:public class Thread1 extends Thread{ @...
  • 调用线程的run方法只是相当于在当前线程中调用一个普通方法,而start则是新建一个线程执行run代码 转载于:https://blog.51cto.com/flyingfish/1666073...
  • 目录java线程run和start区别1.start()方法2.run()方法3.程序范例4.参考资料 java线程run和start区别 run只是Thread里面一个普通方法,start是启动线程的方法。 start()方法让一个线程进入就绪队列等待分配...
  • java线程run和start方法的区别 1.start()方法来启动线程,真正实现了多线程运行,这时无需等待run方法体代码执行完毕而直接继续执行下面的代码: 通过调用Thread类的start()方法来启动一个线程,  这时此线程...
  • 主要介绍了java线程start和run的区别详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了java中thread线程start和run的区别,run()是Runnable接口中定义的一个方法,是为了让客户程序员在这个方法里写自己的功能代码的。直接调用普通的类调用自己的成员方法是没有任何区别的
  • Java线程run和start方法的区别 转载于:https://www.cnblogs.com/Android9527/p/5422277.html
  • 通过调用Thread类的start()方法来启动一个线程,这时此线程处于就绪(可运行)状态,并没有运行,一旦得到cpu时间片,就开始执行run()方法,这里方法run()称为线程体,它包含了要执行这个线程的内容,Run方法运行...
  • java中thread的start()和run()的区别: 1.start()方法来启动线程,真正实现了多线程运行,这时无需等待run方法体代码执行完毕而直接继续执行下面的代码: 通过调用Thread类的start()方法来启动一个线程, ...
  • start相当于去游乐园排队,run则相当于在玩游乐园项目
  • Java 线程run start区别

    2015-06-11 14:51:18
    得运行完run里面代码整个程序才能往下进行,而如果调用start方法,线程和MAIN方法就会抢资源,打印语句会交替出现,你把线程循环次数加到300,试一下依次调runstart和两次都调start方法时所出现情况应该...
  • 原创作品,允许转载,转载时请务必以超链接形式标明文章 原始出处 、作者信息本声明。...用start方法来启动线程,真正实现了多线程运行,这时无需等待run方法体代码执行完毕而直接继续执行下面代码。通过调用Thr

空空如也

空空如也

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

java线程run和start的区别

java 订阅