start()方法和run()方法区别与多线程抢占式运行原理

简介: 我们通过一个例子来进行总结,我们写一个利用Thread创建的简单的多线程例子,然后分别执行start()与run()方法,执行结果如下所示:

start()与run()方法区别

我们通过一个例子来进行总结,我们写一个利用Thread创建的简单的多线程例子,然后分别执行start()与run()方法,执行结果如下所示:

/**
 * @author :zjc
 * @ProjectName: execises
 * @Package: com.execises.zjc.controller.thread
 * @ClassName: ThreadRunAndStartMethodCompare
 * @date :Created in 2021/7/17 10:20
 * @description:对比run()和start()方法
 * @modified By:
 * @version: v1.0.0$
 */
public class ThreadRunAndStartMethodCompare extends Thread {
    private String name;
    public ThreadRunAndStartMethodCompare(String name) {
        this.name = name;
    }
    @Override
    public void run() {
        super.run();
        System.out.println(name);
    }
    public static void main(String[] args) {
        new ThreadRunAndStartMethodCompare("唐山大兄本兄").run();
        //new ThreadRunAndStartMethodCompare("唐山大兄本兄").start();
    }
}

这里先执行了start()方法


在这里插入图片描述


在执行时,我们看到新生成了一个线程,这样与主线程分离开,实现了并行执行。


start()方法来启动线程,真正实现了多线程运行,这时无需等待run方法体代码执行完毕而直接继续执行下面的代码:

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

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

3、run()方法运行结束,此线程终止,而CPU再运行其它线程。

执行run方法


在这里插入图片描述


run()方法在这里可以看到并没有线程产生,只有单独的主进程


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


Thread底层也是用Runnable的run()方法来执行,其中target就是Runnable的变量名。

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

Thread对象的run()方法在一种循环下,使线程一直运行,直到不满足条件为止,在你的main()里创建并运行了一些线程,调用Thread类的start()方法将为线程执行特殊的初始化的过程,来配置线程,然后由线程执行机制调用run()方法。如果你不调用start()方法,线程就不会启动。


因为线程调度机制的行为是不确定的,所以每次运行该程序都会有不同的结果,你可以把你的循环次数增多些,然后看看执行的结果,你会发现main()的主线程和Thread子线程是交替运行的。我们看下面一段代码:

/**
 * @author :zjc
 * @ProjectName: execises
 * @Package: com.execises.zjc.controller.thread
 * @ClassName: ThreadOpByThread
 * @date :Created in 2021/7/16 15:03
 * @description:创建多线程之继承Thread类
 * @modified By:
 * @version: v1.0.0$
 */
public class ThreadOpByThread extends Thread {
    @Override
    public void run() {
        super.run();
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
    static class testThread {
        public static void main(String[] args) {
            ThreadOpByThread threadOpByThread = new ThreadOpByThread();
            threadOpByThread.start();
            for (int i = 0; i < 100; i++) {
                System.out.println("我是主线程"+ i);
            }
        }
    }
}

输出结果为:

我是主线程0
Thread-00
我是主线程1
Thread-01
Thread-02
Thread-03
Thread-04
Thread-05
我是主线程2
我是主线程3
我是主线程4
我是主线程5
我是主线程6
我是主线程7
我是主线程8
Thread-06

在执行过程中会相互并发穿插执行,子线程执行完毕后依然会回到主线程,交给主线程最终执行,这也就是并发执行的高效率之所在。

多线程抢占式运行原理

经过我运行下面这段代码,发现每次生成的线程顺序号都是会变的,并不是按照顺序来执行:

/**
 * @author :zjc
 * @ProjectName: execises
 * @Package: com.execises.zjc.controller.thread
 * @ClassName: ThreadRunAndStartMethodCompare
 * @date :Created in 2021/7/17 10:20
 * @description:对比run()和start()方法
 * @modified By:
 * @version: v1.0.0$
 */
public class ThreadRunAndStartMethodCompare extends Thread {
    private String name;
    public ThreadRunAndStartMethodCompare(String name) {
        this.name = name;
    }
    public ThreadRunAndStartMethodCompare() {
    }
    @Override
    public void run() {
        super.run();
        System.out.println(name);
    }
    public static void main(String[] args) {
        ThreadRunAndStartMethodCompare threadRunAndStartMethodCompare = new ThreadRunAndStartMethodCompare();
        //new ThreadRunAndStartMethodCompare("张建超").run();
        for (int i = 0; i < 100; i++) {
            threadRunAndStartMethodCompare.demo(i);
        }
    }
    public void demo(int i) {
        synchronized (this) {
            new ThreadRunAndStartMethodCompare("唐山大兄本兄" + i).start();
        }
    }
}

输出结果:

唐山大兄本兄0
唐山大兄本兄5
唐山大兄本兄3
唐山大兄本兄2
唐山大兄本兄1
唐山大兄本兄4
唐山大兄本兄6
唐山大兄本兄7
唐山大兄本兄8
唐山大兄本兄10
唐山大兄本兄18
唐山大兄本兄12
唐山大兄本兄20
唐山大兄本兄13
唐山大兄本兄14


image.png

原因:

1、当java虚拟机(也就是经常说的 JVM)执行mian方法的时候,他会找操作系统(也就是os)开辟一条main方法通向cpu的路径,这个路径就是main线程,也就是所说的主线程。

2、接着cpu通过这个线程,也就是这个路径,就可以执行main方法了。

3、当我们new了一个Thread对象,这个时候又开辟了一条通向cpu的路径,而这条路径是用来执行run方法的。

4、而现在对于cpu而言,他就有了很多条执行的路径,cpu就有了选择的权利,cpu他喜欢谁,就会执行哪条路径,我们是控制不了cpu的,所有就有了出现随机打印的结果。

反过来说,两个线程,一个main线程,一个新线程,他们一起抢夺cpu的执行权(即 cpu的执行时间),谁抢到了,谁先执行。


也可以这么来理解:

0到99这段时间太短,对于CPU分配给这个线程的时间片来说足够完成了,也就呈现出0到99个线程同时初始化,然后剩下的线程再争夺CPU资源,在我们Debug调试的时候输出就是0到99的顺序,不用Debug调试直接运行就不是0到99输出。大致可以理解为创建了所有的线程,再争用资源。调试的时候有断点,产生了优先级,所以才按序输出的。

这边发现一个讲run()和start()的比较详细的文章,链接地址放在这里:

https://blog.csdn.net/chengp919/article/details/77336328


欢迎感兴趣的小伙伴一起探讨学习知识,以上是个人的一些总结分享,如有错误的地方望各位留言指出,十分感谢。


觉得有用的话别忘点赞、收藏、关注,手留余香! 😗 😗 😗

相关文章
|
3月前
|
存储 缓存 Java
什么是线程池?从底层源码入手,深度解析线程池的工作原理
本文从底层源码入手,深度解析ThreadPoolExecutor底层源码,包括其核心字段、内部类和重要方法,另外对Executors工具类下的四种自带线程池源码进行解释。 阅读本文后,可以对线程池的工作原理、七大参数、生命周期、拒绝策略等内容拥有更深入的认识。
150 29
什么是线程池?从底层源码入手,深度解析线程池的工作原理
|
2月前
|
Java 开发者
在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口
【10月更文挑战第20天】在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口。本文揭示了这两种方式的微妙差异和潜在陷阱,帮助你更好地理解和选择适合项目需求的线程创建方式。
27 3
|
2月前
|
Java 开发者
在Java多线程编程中,选择合适的线程创建方法至关重要
【10月更文挑战第20天】在Java多线程编程中,选择合适的线程创建方法至关重要。本文通过案例分析,探讨了继承Thread类和实现Runnable接口两种方法的优缺点及适用场景,帮助开发者做出明智的选择。
23 2
|
2月前
|
安全 Java
Java多线程通信新解:本文通过生产者-消费者模型案例,深入解析wait()、notify()、notifyAll()方法的实用技巧
【10月更文挑战第20天】Java多线程通信新解:本文通过生产者-消费者模型案例,深入解析wait()、notify()、notifyAll()方法的实用技巧,包括避免在循环外调用wait()、优先使用notifyAll()、确保线程安全及处理InterruptedException等,帮助读者更好地掌握这些方法的应用。
24 1
|
2月前
|
Java 开发者
Java多线程初学者指南:介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点
【10月更文挑战第20天】Java多线程初学者指南:介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点,重点解析为何实现Runnable接口更具灵活性、资源共享及易于管理的优势。
44 1
|
2月前
|
Java
在Java多线程编程中,`wait()`和`notify()`方法的相遇如同一场奇妙的邂逅
在Java多线程编程中,`wait()`和`notify()`方法的相遇如同一场奇妙的邂逅。它们用于线程间通信,使线程能够协作完成任务。通过这些方法,生产者和消费者线程可以高效地管理共享资源,确保程序的有序运行。正确使用这些方法需要遵循同步规则,避免虚假唤醒等问题。示例代码展示了如何在生产者-消费者模型中使用`wait()`和`notify()`。
32 1
|
2月前
|
安全 Java 开发者
Java多线程中的`wait()`、`notify()`和`notifyAll()`方法,探讨了它们在实现线程间通信和同步中的关键作用
本文深入解析了Java多线程中的`wait()`、`notify()`和`notifyAll()`方法,探讨了它们在实现线程间通信和同步中的关键作用。通过示例代码展示了如何正确使用这些方法,并分享了最佳实践,帮助开发者避免常见陷阱,提高多线程程序的稳定性和效率。
50 1
|
2月前
|
Java
在Java多线程编程中,`wait()` 和 `notify()/notifyAll()` 方法是线程间通信的核心机制。
在Java多线程编程中,`wait()` 和 `notify()/notifyAll()` 方法是线程间通信的核心机制。它们通过基于锁的方式,使线程在条件不满足时进入休眠状态,并在条件成立时被唤醒,从而有效解决数据一致性和同步问题。本文通过对比其他通信机制,展示了 `wait()` 和 `notify()` 的优势,并通过生产者-消费者模型的示例代码,详细说明了其使用方法和重要性。
31 1
|
2月前
|
监控 Java
在实际应用中选择线程异常捕获方法的考量
【10月更文挑战第15天】选择最适合的线程异常捕获方法需要综合考虑多种因素。没有一种方法是绝对最优的,需要根据具体情况进行权衡和选择。在实际应用中,还需要不断地实践和总结经验,以提高异常处理的效果和程序的稳定性。
30 3
|
2月前
|
监控 Java
捕获线程执行异常的多种方法
【10月更文挑战第15天】捕获线程执行异常的方法多种多样,每种方法都有其特点和适用场景。在实际开发中,需要根据具体情况选择合适的方法或结合多种方法来实现全面有效的线程异常捕获。这有助于提高程序的健壮性和稳定性,减少因线程异常带来的潜在风险。
30 1