精华内容
下载资源
问答
  • 多线程的run和start的区别
    2021-11-11 16:26:34

    假设程序中只有主线程和其他一个线程

    1、首先先了解在Java中,线程通常有五种状态:创建,就绪,运行,阻塞和死亡。

    ①创建:在生成线程对象,并没有调用该对象的start方法,这时线程处于创建状态。内存会开辟一条路径到cpu。

    ②就绪状态:当调用了线程对象的start方法之后,该线程就进入就绪状态。

    运行,阻塞,死亡这里不解释

    2、start()方法就相当于一个按钮,按下这个按钮后程序并没有运行,一旦得到cpu时间片,JVM就开始执行run()方法,这里方法 run()称为线程体,它包含了要执行的这个线程的内容,Run方法运行结束,此线程随即终止。

    更多相关内容
  • 目录java多线程run和start区别1.start()方法2.run()方法3.程序范例4.参考资料 java多线程run和start区别 run只是Thread里面的一个普通方法,start是启动线程的方法。 start()方法让一个线程进入就绪队列等待分配...

    java多线程中run和start区别

    run只是Thread里面的一个普通方法,start是启动线程的方法。

    start()方法让一个线程进入就绪队列等待分配 cpu, 分到 cpu 后才调用实现的run()方法。

    start()方法不能重复调用, 如果重复调用会抛出异常。
    而 run 方法是业务逻辑实现的地方, 本质上和任意一个类的任意一个成员方法并没有任何区别, 可以重复执行, 也可以被单独调用。


    1.start()方法

    start()方法来启动线程,无需等待run方法体代码执行完毕,可以直接继续执行下面的代码;

    jvm通过调用Thread类的start()方法来启动一个线程, 这时此线程是处于就绪状态, 并没有运行。

    然后通过此Thread类调用方法run()来完成其运行操作的, 这里方法run()称为线程体,它包含了要执行的这个线程的内容, run方法运行结束, 此线程终止。

    然后其他线程再抢cpu的控制权接着执行,这是真正实现了多线程。


    2.run()方法

    run()方法当作普通方法的方式调用。程序还是要顺序执行,要等待run方法体执行完毕后,才可继续执行下面的代码; 程序中只有主线程——这一个线程,其程序执行路径还是只有一条。这并非多线程,还只是单线程。


    3.程序范例

    public class MyThread1 extends Thread {
        @Override
        public void run() {
            try {
                System.out.println("run threadName="+ this.currentThread().getName()+"begin");
                Thread.sleep(2000);
                System.out.println("run threadName="+this.currentThread().getName()+"end");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    public class Run1 {
        public static void main(String[] args) {
            final MyThread1 myThread1 = new MyThread1();
            System.out.println("begin="+System.currentTimeMillis());
            myThread1.run();
            System.out.println("end="+System.currentTimeMillis());
        }
    }
    

    在这里插入图片描述

    public class Run2 {
        public static void main(String[] args) {
            final MyThread1 myThread2 = new MyThread1();
            System.out.println("begin="+System.currentTimeMillis());
            myThread2.start();
            System.out.println("end="+System.currentTimeMillis());
        }
    }
    

    在这里插入图片描述

    4.参考资料

    java多线程中run和start区别

    展开全文
  • 多线程run()和start()区别*

    千次阅读 2020-09-01 17:10:37
    start()方法它的作用是启动一个新线程,run()就普通的成员方法一样,可以被重复调用。 这个问题经常被问到,但还是能从此区分...通过该方法启动线程的同时也创建了一个线程,真正实现了多线程。无需等待run()方法中的

    start()方法它的作用是启动一个新线程,run()就和普通的成员方法一样,可以被重复调用。

    这个问题经常被问到,但还是能从此区分出面试者对Java线程模型的理解程度。start()方法被用来启动新创建的线程,而且start()内部 调用了run()方法,这和直接调用run()方法的效果不一样。当你调用run()方法的时候,只会是在原来的线程中调用,没有新的线程启动,start()方法才会启动新线程。

    start方法:

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

    run方法:

    通过run方法启动线程其实就是调用一个类中的方法,当作普通的方法的方式调用。并没有创建一个线程,程序中依旧只有一个主线程,必须等到run()方法里面的代码执行完毕,才会继续执行下面的代码,这样就没有达到写线程的目的。
    而run方法是业务逻辑实现的地方,本质上和任意一个类的任意一个成员方法并没有任何区别,可以重复执行,被一个线程反复调用,也可以被单独调用

    总结一下:
    1.start() 可以启动一个新线程,run()不能
    2.start()不能被重复调用,run()可以
    3.start()中的run代码可以不执行完就继续执行下面的代码,即进行了线程切换。直接调用run方法必须等待其代码全部执行完才能继续执行下面的代码。
    4.start() 实现了多线程,run()没有实现多线程。

    展开全文
  • 主要介绍了java中thread线程start和run区别,run()是Runnable接口中定义的一个方法,是为了让客户程序员在这个方法里写自己的功能代码的。直接调用普通的类调用自己的成员方法是没有任何区别
  • 结论:启动线程,如果对target进行赋值,并且没有重写run方法,则线程start的时候会直接调用target中对应的方法 具体代码如下: 1、初始化一个线程 threading.Thread.__init__(self,target=thread_run()) def __...

    结论:启动线程,如果对target进行赋值,并且没有重写run方法,则线程start的时候会直接调用target中对应的方法

    具体代码如下:
    1、初始化一个线程

    threading.Thread.__init__(self,target=thread_run())
    
    def __init__(self, group=None, target=None, name=None,
                     args=(), kwargs=None, *, daemon=None):
            assert group is None, "group argument must be None for now"
            if kwargs is None:
                kwargs = {}
            self._target = target
            self._name = str(name or _newname())
            self._args = args
            self._kwargs = kwargs
    

    2、调用start启动线程
    最终调用_start_new_thread方法,self._bootstrap作为传参

    thread1.start()
        def start(self):
            if not self._initialized:
                raise RuntimeError("thread.__init__() not called")
            if self._started.is_set():
                raise RuntimeError("threads can only be started once")
            with _active_limbo_lock:
                _limbo[self] = self
            try:
                _start_new_thread(self._bootstrap, ())
            except Exception:
                with _active_limbo_lock:
                    del _limbo[self]
                raise
            self._started.wait()
    

    3、_start_new_thread等同于启动一个新线程,并在新线程中调用回调函数

    _start_new_thread = _thread.start_new_thread
    def start_new_thread(function: Callable[..., Any], args: tuple[Any, ...], kwargs: dict[str, Any] = ...) -> int: ...
    

    4、执行的回调函数就是上文传入的self._bootstrap, _bootstrap方法直接调用_bootstrap_inner(),而bootstrap_inner则调用run方法

    def _bootstrap_inner(self):
        try:
            self._set_ident()
            self._set_tstate_lock()
            if _HAVE_THREAD_NATIVE_ID:
                self._set_native_id()
            self._started.set()
            with _active_limbo_lock:
                _active[self._ident] = self
                del _limbo[self]
    
            if _trace_hook:
                _sys.settrace(_trace_hook)
            if _profile_hook:
                _sys.setprofile(_profile_hook)
            try:
                self.run()
    

    5、最终调用run方法

     def run(self):
            try:
                if self._target:
                    self._target(*self._args, **self._kwargs)
            finally:
                # Avoid a refcycle if the thread is running a function with
                # an argument that has a member that points to the thread.
                del self._target, self._args, self._kwargs
    

    结论:
    如果run方法被重写,则直接调用重写的run方法
    如果run方法没有被重写,并且target被定义,则会直接调用线程创建时候的target方法,否则什么也不做

    此处遇到一问题:
    指定target参数,在执行过程中,打印的进程名mainthread(主进程),而不是之前所赋的进程名
    threading.Thread.init(self,target=thread_run())
    分析后发现赋予target的是执行的函数体,因此会先执行thread_run函数,执行结束后,将thread_run的返回值赋给了target,因为thread_run没有返回值,因此target的值是None,如果此时没有重写run函数,那么线程什么都不会做。 thread_run的执行是在主线程,而不是我们所认为的在子线程中执行thread_run

    def thread_run():
        print ("overwrite: 开始线程:" + threading.current_thread().name)
        time.sleep(2)
        print ("overwrite: 退出线程:" + threading.current_thread().name)
    
    class myThread (threading.Thread):
        def __init__(self, threadID, name, delay):
            threading.Thread.__init__(self,target=thread_run())
            self.threadID = threadID
            self.name = name
            self.delay = delay
            thread1.start()
    
    thread1.join()
    print ("退出主线程")
    

    运行结果:

    overwrite: 开始线程:MainThread
    overwrite: 退出线程:MainThread
    退出主线程
    
    展开全文
  • 多线程run和start方法的区别 我们run()方法只是一个类的普通方法,调用后自动压栈执行,执行完后弹栈便可 但是我们start()方法作用开启一个分支线程,在JVM中开辟一块新的栈空间,代码执行完,自动结束,也就是...
  • (1) run()方法称为线程体,即线程的任务处理逻辑通过run()方法来实现,它由Java虚拟机在运行相应线程时直接调用,而不应由应用代码调用,如果在应用代码中调用,run()方法就是一个普通方法而已,程序中依然只有主线...
  • java多线程run和start方法的区别

    万次阅读 多人点赞 2018-01-24 09:05:36
    1 java中多线程有两个常见的方法start方法和run方法。正常来说run方法是多线程的线程体。 2 创建线程,可以使用extends Threadimplements Runnable 如:public class Thread1 extends Thread{ @...
  • 主要介绍了java线程start和run区别详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • start()和run()方法的主要区别在于: 当程序调用start()方法,一个新线程将会被创建,并且在run()方法中的代码会在新线程上运行。 当直接调用run()方法时,程序并不会创建新线程run()方法内部的代码在当前线程...
  • 线程start方法和run方法的区别

    千次阅读 2022-05-03 16:18:54
    线程start方法和run方法的区别
  • run方法和start的调用方法区别在于哪? 相信看到此处的人们,都会有类似的疑问,这篇文章就为你打开新世界,铭记脑海中 1. 定义 查看其官方的api接口定义 start方法 “ “Causes this thread to begin execution; ...
  • 主要介绍了java 线程中start方法与run方法的区别详细介绍的相关资料,在java线程中调用start方法与run方法的区别在哪里? 这两个问题是两个非常流行的初学者级别的多线程面试问题,这里进行详细说明,需要的朋友可以...
  • 线程run() start() 有什么区别

    万次阅读 2019-05-15 17:21:56
    线程的 run() start() 有什么区别? 调用 start() 方法是用来启动线程的,轮到该线程执行时,会自动调用 run();直接调用 run() 方法,无法达到启动多线程的目的,相当于主线程线性执行 Thread 对象的 run() ...
  • start方法来启动线程,真正实现了多线程运行,这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的 start()方法来启动一个线程,这时此线程处于就绪(可运行)状态,并没有运行,一旦...
  • 线程start() run()的区别

    千次阅读 2022-03-08 16:38:34
    start() 会执行线程的相应准备工作,然后自动执行run() 方法的内容,这是真正的多线程工作。 而直接执行run() 方法,会把run 方法当成一个main 线程下的普通方法去执行,并不会在某个线程中执行它,所以这并不是...
  • 多线程run()和start()的区别run():封装进入线程的代码,直接被调用就是普通对象的调用,不开启线程 start():开启线程,被对象调用之后JVM自动调用run()方法。
  • 参考博客: ... ... 总结就是: start() 方法是启动一个子线程,在该子线程中执行run方法,而线程名就是我们定义的name run() 方法并不启动一个新线程,就是在...因此,如果你想启动多线程,就必须使用start()方法。 ...
  • 线程的 run() start() 有什么区别? 调用 start() 方法是用来启动线程的,轮到该线程执行时,会自动调用 run();直接调用 run() 方法,无法达到启动多线程的目的,相当于主线程线性执行 Thread 对象的 run() ...
  • 1.创建多线程的方法 1.继承Thread类,重写run方法,使用start方法创建一个线程 2.实现Runnable接口,重写run方法,通过new Thread(Runnable target).start创建一个线程 2.start()方法 通过调用start()方法来启动...
  • 线程run() start()有什么区别

    千次阅读 2021-04-09 16:28:58
    start方法来启动线程,真正实现了多线程运行,这时无需等待run方法体中的代码执行完毕而直接继续执行后续的代码。通过调用Thread类的 start()方法来启动一个线程,这时此线程处于就绪(可运行)状态,并没有运行,...
  • 比如创建一个线程 Thread t1 = new Thread() t1.run(); 只是调用了一个普通方法,并没有启动另一个线程,程序还是会按照...线程run()方法是由java虚拟机直接调用的,如果我们没有启动线程(没有调用线程start()...
  • start方法来启动线程,真正实现了多线程运行,即无需等待某个线程的run方法体代码执行完毕就直接继续执行下面的代码。这里无需等待run方法执行完毕,即可继续执行下面的代码,即进行了线程切换。 run() r
  • start()方法真正实现了多线程。 当程序调用start()方法时,会自动开启一个线程,并接着执行下面方法,此时就实现了多线程。而开启的线程此时属于就绪状态,等到获得cpu的时间片后,就会开始执行线程的run()方法,run...
  • 主要介绍了Thread中start()和run()的区别,Thread类包含start()和run()方法,它们的区别是什么?下面将对此作出解答
  • 1、调用多线程时用start() 2、start()中会调用run() 3、run()不会启动多线程 代码分析: 1、首先看run()的代码: def run(self): """Method representing the thread's activity. You may override this...
  • start() 它的作用是启动一个新线程。 通过start()方法来(private native...用start方法来启动线程,真正实现了多线程运行,即无需等待某个线程的run方法体代码执行完毕就直接继续执行下面的代码。这里无需等待run方法.
  • 线程中的start()方法和run()的区别

    千次阅读 2020-09-14 11:03:17
    1、线程中的start()方法和run()方法的主要区别在于,当程序调用start()方法,将会创建一个新线程去执行run()方法中的代码。但是如果直接调用run()方法的话,会直接在当前线程中执行run()中的代码,注意,这里不会...
  • start()方法它的作用是启动一个新线程run()就普通的成员方法一样,可以被重复调用。接下来通过本文给大家分享Java中启动线程start和run的两种方法,需要的朋友参考下吧

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 452,130
精华内容 180,852
关键字:

多线程的run和start的区别