线程的启动的两种方法,Runnable接口,run()的调用

实现并启动线程有两种方法
1、写一个类继承自Thread类,重写run方法。用start方法启动线程
2、写一个类实现Runnable接口,实现run方法。用new Thread(Runnable target).start()方法来启动

多线程原理:相当于玩游戏机,只有一个游戏机(cpu),可是有很多人要玩,于是,start是排队!等CPU选中你就是轮到你,你就run(),当CPU的运行的时间片执行完,这个线程就继续排队,等待下一次的run()。

调用start()后,线程会被放到等待队列,等待CPU调度,并不一定要马上开始执行,只是将这个线程置于可动行状态。然后通过JVM,线程Thread会调用run()方法,执行本线程的线程体。先调用start后调用run,这么麻烦,为了不直接调用run?就是为了实现多线程的优点,没这个start不行。

1.start()方法来启动线程,真正实现了多线程运行。这时无需等待run方法体代码执行完毕,可以直接继续执行下面的代码;通过调用Thread类的start()方法来启动一个线程, 这时此线程是处于就绪状态, 并没有运行。 然后通过此Thread类调用方法run()来完成其运行操作的, 这里方法run()称为线程体,它包含了要执行的这个线程的内容, Run方法运行结束, 此线程终止。然后CPU再调度其它线程。
2.run()方法当作普通方法的方式调用。程序还是要顺序执行,要等待run方法体执行完毕后,才可继续执行下面的代码; 程序中只有主线程——这一个线程, 其程序执行路径还是只有一条, 这样就没有达到写线程的目的。

记住:多线程就是分时利用CPU,宏观上让所有线程一起执行 ,也叫并发

 1 public class Test {
 2     public static void main(String[] args) {
 3         Runner1 runner1 = new Runner1();
 4         Runner2 runner2 = new Runner2();
 5 //      Thread(Runnable target) 分配新的 Thread 对象。
 6         Thread thread1 = new Thread(runner1);
 7         Thread thread2 = new Thread(runner2);
 8 //      thread1.start();
 9 //      thread2.start();
10         thread1.run();
11         thread2.run();
12     }
13 }
14
15 class Runner1 implements Runnable { // 实现了Runnable接口,jdk就知道这个类是一个线程
16     public void run() {
17         for (int i = 0; i < 100; i++) {
18             System.out.println("进入Runner1运行状态——————————" + i);
19         }
20     }
21 }
22
23 class Runner2 implements Runnable { // 实现了Runnable接口,jdk就知道这个类是一个线程
24     public void run() {
25         for (int i = 0; i < 100; i++) {
26             System.out.println("进入Runner2运行状态==========" + i);
27         }
28     }
29 }  

以上整理来自:http://blog.csdn.net/xuxurui007/article/details/7685076

【线程的创建和启动的步骤实现Runnable接口方式)】

1.定义Runnable接口的实现类,并重写其中的run方法。run()方法的方法体线程执行体

class SonThread  implement Runnable{

  public void run(){

  ......

  }

 }

2.创建Runnable接口实现类的实例。                        sonThread s1=new SonThread();

3.用该实例作为Thread的target来创建Thread对象。   Thread t1 =new Thread(s1);

4.调用该对象的start()方法启动线程。                       t1.start();

【注意一:关于命名】

在创建Thread 对象的时候可以为该Thread对象指定一个名字

【注意二:Thread的构造方法】

Runnable对象作为Thread对象的target,Runnable实现类里面包含run方法仅仅作为执行体。也就是说Thread类的作用是把run方法包装成线程的执行体。

实际运行的线程对象依然是Thread实例,只是该Thread线程负责执行其target的run方法。

 1 //1.1定义Runnable接口的实现类
 2 class SecondThread implements Runnable{
 3
 4     //1.2重写其中的run方法
 5     @Override
 6     public void run() {
 7         for(int i=0;i<10;i++){
 8             System.out.println(Thread.currentThread().getName()+"===="+i);
 9         }
10     }
11
12 }
13 public class Demo2 {
14
15     public static void main(String[] args) {
16         //2.创建Runnable的接口实现类的实例
17         SecondThread s1=new SecondThread();
18         SecondThread s2=new SecondThread();
19         //2.用Runnable的接口实现类的实例作为Thread的target,创建Thread对象
20         Thread t1=new Thread(s1);
21         Thread t2=new Thread(s2,"Higgin");  //创建Thread对象的同时可以为之命名
22
23         //启动线程
24         t1.start();
25         t2.start();
26
27         for(int i=0;i<10;i++){
28             System.out.println(Thread.currentThread().getName()+"===="+i);
29         }
30     }
31 }

以上整理来自:http://www.cnblogs.com/HigginCui/p/5901593.html

通过JDK源码解析Thread(Runable target ...)调用的是哪个run方法

代码1:

 1 new Thread(new Runnable() {
 2     @Override
 3     public void run() {
 4         System.out.println("Run of Runnable");
 5     }
 6 }) {
 7     public void run() {
 8         System.out.println("Run of Thread");
 9     }
10 }.start();  

代码2:

 1 new Thread(new Runnable() {
 2     @Override
 3     public void run() {
 4         System.out.println("Run of Runnable");
 5     }
 6 }) {
 7     public void run() {
 8         System.out.println("Run of Thread");
 9         super.run();
10     }
11 }.start();  

首先,我们来看一下JDK的Thread源码,片段 3 如下:

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

在run()方法中,首先会检查target是否为空,如果不是,则执行该target的run()方法。

那么,对于上面两段代码的执行,也就清楚了。

在第一个代码段 1 中,重写了Thread的run()方法,同时传入了一个Runnable对象,该对象也实现了run()方法。该Thread对象调用start()方法后,会执行该对象重写的run()方法,其输出结果也就是Run of Thread,输出完后,run()方法返回,该线程对象的生命周期也就结束了。

在第二个代码段 2 中,同样也重写了Thread的run()方法,同时传入了一个Runnable对象,实现了run()方法。唯一不同的是,在Thread重写的run方法中,在打印输出后,还执行了super.run(),这就有意思了。

首先,该线程启动运行后,执行其重写的run()方法,输出Run of Thread。

接下来调用super.run(),也就是调用超类的run()方法,而该超类的run()方法,也就是JDK定义的Thread类的run(),其执行如上代码段 3 所示;显然target不为空,这时候会调用该对象的run()方法,会输出Run of Runnable.。

如果,上面的Thread并未重写run()方法,那么,执行的结果还是一样。首先会执行该Thread的run()方法,因为此时并未重写该方法,所以还是会调用JDK定以的run()方法,也就是上面的代码段 3,在该代码段中会判断target是否为空,显然不是,所以会调用Runnable对象实现的run()方法。

总结:对于Thread(Runnable target ...),不管传入的Target是否为空,首先都会执行Thread自己的run()方法。如果重写了该方法且该方法中没有super.run(),那么是永远不会调用Runnable实现的run()方法;如果没有重写该方法,则会去判断target是否为空,以此来决定调用target实现的run()方法;如果重写了该方法,且该方法中有super.run(),在执行完该语句之前的所有代码后,会判断target是否为空,以此来决定调用target实现的run()方法,执行完后,接着执行该语句之后的代码。

以上整理来自:http://blog.csdn.net/guguituzi/article/details/44593863

时间: 2024-10-06 21:30:03

线程的启动的两种方法,Runnable接口,run()的调用的相关文章

华硕笔记本怎么设置u盘启动(两种方法)

华硕笔记本怎么设置u盘启动(两种方法) 华硕笔记本怎么设置u盘启动.我想用U盘安装系统但是 我不知道如何设置U盘启动,那么该如何设置呢?下面和大家分享一下我的经验,希望能够帮到大家.如果你的系统是预装win8的系统,那么如果你要想安装win7系统,需要你在BIOS中有相关的设置,你可以看我之前的经验,建议在百度上搜索---华硕笔记本预装win8改win7如何在bios中设置 工具/原料 华硕笔记本 U盘启动 方法一.bios设置开机启动 1 开机长按F2键,进入bios. 2 我们左右移动找到"

两种方法使vue实现jQuery调用

引言 如果说vue是前端工程化使用较多的骨架,那么JavaScript就是我们的前端的细胞.MVVM模式让我们体验到前端开发的便携,无需再过多的考虑DOM的操作.而vue的渐进式开发(逐步引用组件,按需引入),也让许多新手前端开发人员逐步绕过对jQuery的学习.jQuery需要记忆的内容颇多,这也让jQuery变得不那么受新入行开发者喜欢. 在前端工程化的需求没有普及的时候,许多公司使用的是后端渲染技术,为了能够实现友好的前端交互效果,需要写好大量的jQuery.JavaScript和CSS,

java中一个类要当作线程来使用有两种方法

1.继承Thread类,并重写run函数 2.实现Runnable接口,并重写run函数 因为java是单继承的,在某些情况下一个类可能已经继承了某个父类,这时在用继承Thread类方法来创建线程显然不可能java设计者们提供了另外一个方式创建线程,就是通过实现Runnable接口来创建线程.

C#多线程开发3:给线程传递数据的两种方法

定义需要传递给线程的数据. class Student { public string Name { get; set; } public int Age { get; set; } public int Score { get; set; } } List<Student> studentList = new List<Student>() { new Student(){Name="zhangsan",Age=20,Score=5}, new Student

启动线程的两种方法的对比

java中Thread类有两种启动方法: 1.Thread.start() 2.Thread.run() 这两种方法的执行效果并不一样.Thread.start()方法是通知"线程规划器"此线程已经准备就绪,等待调用线程对象run()方法,是异步的执行结果. Thread.run()方法则是同步的,并不交给"线程规划器"来处理,而是由调用此线程的线程直接调用线程的run()方法,必须等run()方法中的代码执行完以后才能执行后面的代码 另外,执行start()方法的

(转)java创建线程的两种方法比较

Java提供了线程类Thread来创建多线程的程序.其实,创建线程与创建普通的类的对象的操作是一样的,而线程就是Thread类或其子类的实例对象.每个Thread对象描述了一个单独的线程.要产生一个线程,有两种方法: ◆需要从Java.lang.Thread类派生一个新的线程类,重载它的run()方法:  ◆实现Runnalbe接口,重载Runnalbe接口中的run()方法. 为什么Java要提供两种方法来创建线程呢?它们都有哪些区别?相比而言,哪一种方法更好呢? 在Java中,类仅支持单继承

Java 创建线程的两种方法

Java提供了线程类Thread来创建多线程的程序.其实,创建线程与创建普通的类的对象的操作是一样的,而线程就是Thread类或其子类的实例对象.每个Thread对象描述了一个单独的线程.要产生一个线程,有两种方法: ◆需要从Java.lang.Thread类派生一个新的线程类,重载它的run()方法: ◆实现Runnalbe接口,重载Runnalbe接口中的run()方法. 为什么Java要提供两种方法来创建线程呢?它们都有哪些区别?相比而言,哪一种方法更好呢? 在Java中,类仅支持单继承,

实现多线程的两种方法:继承Thread类或实现Runnable接口

实现多线程的两种方法:继承Thread类或实现Runnable接口 Java中实现多线程有两种方法:继承Thread类和实现Runnable接口,在程序开发中只要是多线程,我们一般都是实现Runnable接口,原因归结为一点:实现接口比继承类要好. 多线程的第一种实现方式:继承Thread类 步骤如下 创建一个继承Thread的类(假定为A),并重写Thread的run方法 构造一个A类对象,假定为aa 调用aa的start方法.(start方法是从Thread继承过来的) 具体例子如下 pac

Android_Timer与Runnable两种方法的定时器

先理清概念: Timer是一个执行任务的类,他接受TimerTask的参数; Timer执行任务有两种方式,一种是在某个指定的时候执行某个任务timer.schedule(Timertask task,Data data),另一种是在多长时间之后执行某个任务timer.schedule(TimerTask task,long delay): TimerTask中执行指定的任务,但由于Android是线程安全的,所有的界面的更新都必须放到主线程中,所以要使用到Handler对象. Android的