extends Thread 与 implements Runnable 的区别

最新推荐文章于 2023-08-22 13:13:02 发布
最新推荐文章于 2023-08-22 13:13:02 发布
阅读量599 收藏
点赞数
分类专栏： java题目

1、通过实现Runnable接口创建线程

(1).定义一个类实现Runnable接口，重写接口中的run()方法。在run()方法中加入具体的任务代码或处理逻辑。

(2).创建Runnable接口实现类的对象。

(3).创建一个Thread类的对象，需要封装前面Runnable接口实现类的对象。（接口可以实现多继承）

(4).调用Thread对象的start()方法，启动线程

[java]  view plain copy
  1. public class ThreadFromRunnable implements Runnable {  
      
         int count = 10;  
        public void run() {  
            System.out.println("\t#"+Thread.currentThread().getName()+" 开始count值 " + count);  
            while(count > 0)  
            {  
            count--;
                System.out.println("#"+Thread.currentThread().getName()+" : count--    "+ count);  
            }  
            System.out.println("#"+Thread.currentThread().getName()+" : 最后count值 "+ count--);  
        }  
        public static void main(String[] args)  
        {  
            ThreadFromRunnable tr = new ThreadFromRunnable();  
            Thread thread = new Thread(tr);  
            Thread thread2 = new Thread(tr);  
              
            thread.start();  
            thread2.start();  
        }  
      
    }  

output：

#Thread-0 开始count值 10
#Thread-1 开始count值 10
#Thread-0 : count--    9
#Thread-1 : count--    8
#Thread-0 : count--    7
#Thread-1 : count--    6
#Thread-0 : count--    5
#Thread-0 : count--    3
#Thread-1 : count--    4
#Thread-0 : count--    2
#Thread-1 : count--    1
#Thread-0 : count--    0
#Thread-1 : 最后count值 0
#Thread-0 : 最后count值 -1


=====================================================================

public class ThreadFromRunnable implements Runnable {  
  
//int count = 10;
    public void run() {  
    int count = 10;  //起不到共享的效果了，局部变量，没意义！！！！！！！！！！！！！！！！！肯定是每个线程独享的！
        System.out.println("\t#"+Thread.currentThread().getName()+" 开始count值 " + count);  
        while(count > 0)  
        {  
        count--;
            System.out.println("#"+Thread.currentThread().getName()+" : count--    "+ count);  
        }  
        System.out.println("#"+Thread.currentThread().getName()+" : 最后count值 "+ count--);  
    }  
    public static void main(String[] args)  
    {  
        ThreadFromRunnable tr = new ThreadFromRunnable();  
        Thread thread = new Thread(tr);  
        Thread thread2 = new Thread(tr);  
          
        thread.start();  
        thread2.start();  
    }  
  
}  


结果如下：

#Thread-0 开始count值 10
#Thread-1 开始count值 10
#Thread-0 : count--    9
#Thread-1 : count--    9
#Thread-0 : count--    8
#Thread-0 : count--    7
#Thread-0 : count--    6
#Thread-0 : count--    5
#Thread-0 : count--    4
#Thread-0 : count--    3
#Thread-0 : count--    2
#Thread-1 : count--    8
#Thread-0 : count--    1
#Thread-1 : count--    7
#Thread-0 : count--    0
#Thread-1 : count--    6
#Thread-0 : 最后count值 0
#Thread-1 : count--    5
#Thread-1 : count--    4
#Thread-1 : count--    3
#Thread-1 : count--    2
#Thread-1 : count--    1
#Thread-1 : count--    0
#Thread-1 : 最后count值 0


=====================================================================

2、通过继承Thread类创建线程

(1).首先定义一个类去继承Thread父类，重写父类中的run()方法。在run()方法中加入具体的任务代码或处理逻辑。
(2).直接创建一个ThreadDemo2类的对象，也可以利用多态性，变量声明为父类的类型。

(3).调用start方法，线程t启动，隐含的调用run()方法。

public class ThreadExtendsThread extends Thread {  
     int count =10;  
    public void run()  
    { 
        System.out.println("\t#"+Thread.currentThread().getName()+" got count from " + count);  
        while(count > 0)  
        {  
           count--;
        System.out.println(this.getName()+" : existing count=" + count);}  
    }
      
    public static void main(String[] args)  
    {  
        ThreadExtendsThread thread = new ThreadExtendsThread();  
        ThreadExtendsThread thread2 = new ThreadExtendsThread();  
        thread.start();  
        thread2.start();  
    }  
} 


结果：

#Thread-0 got count from 10
#Thread-1 got count from 10
Thread-0 : existing count=9
Thread-1 : existing count=9
Thread-0 : existing count=8
Thread-1 : existing count=8
Thread-0 : existing count=7
Thread-1 : existing count=7
Thread-0 : existing count=6
Thread-1 : existing count=6
Thread-0 : existing count=5
Thread-1 : existing count=5
Thread-0 : existing count=4
Thread-1 : existing count=4
Thread-0 : existing count=3
Thread-1 : existing count=3
Thread-0 : existing count=2
Thread-1 : existing count=2
Thread-0 : existing count=1
Thread-1 : existing count=1
Thread-0 : existing count=0
Thread-1 : existing count=0


=====================================================================






[java]  view plain copy
  1. public class ThreadExtendsThread extends Thread {  
  2.      //int count =10;  
  3.     public void run()  
  4.     { 
  5.    int count=10;  //局部变量，没意义！！！！！！！！！！！！！！！
  6.         System.out.println("\t#"+Thread.currentThread().getName()+" got count from " + count);  
  7.         while(count > 0)  
  8.         {  
  9.             System.out.println("{1}quot;+this.getName()+" : "+count--);  
  10.         }  
  11.         System.out.println("{1}quot;+this.getName()+" : existing count=" + count);  
  12.     }  
  13.       
  14.     public static void main(String[] args)  
  15.     {  
  16.         ThreadExtendsThread thread = new ThreadExtendsThread();  
  17.         ThreadExtendsThread thread2 = new ThreadExtendsThread();  
  18.         thread.start();  
  19.         thread2.start();  
  20.     }  
  21. }  
output：

#Thread-0 got count from 10
#Thread-1 got count from 10
$Thread-1 : 10
$Thread-1 : 9
$Thread-1 : 8
$Thread-1 : 7
$Thread-1 : 6
$Thread-1 : 5
$Thread-1 : 4
$Thread-1 : 3
$Thread-1 : 2
$Thread-1 : 1
$Thread-0 : 10
$Thread-1 : existing count=0
$Thread-0 : 9
$Thread-0 : 8
$Thread-0 : 7
$Thread-0 : 6
$Thread-0 : 5
$Thread-0 : 4
$Thread-0 : 3
$Thread-0 : 2
$Thread-0 : 1
$Thread-0 : existing count=0


=====================================================================



3、两种方式的比较

首先分析两种方式的输出结果，同样是创建了两个线程，为什么结果不一样呢？

使用实现Runnable接口方式创建线程可以共享同一个目标对象（TreadDemo1 tt=new TreadDemo1();），实现了多个相同线程处理同一份资源。

然后再看一段来自JDK的解释：

The Runnable interface should be implemented by any class whose instances are intended to be executed by a thread. The class must define a method of no arguments calledrun.

This interface is designed to provide a common protocol for objects that wish to execute code while they are active. For example,Runnable is implemented by classThread. Being active simply means that a thread has been started and has not yet been stopped.

In addition, Runnable provides the means for a class to be active while not subclassingThread. A class that implementsRunnable can run without subclassingThread by instantiating aThread instance and passing itself in as the target. In most cases, theRunnable interface should be used if you are only planning to override therun() method and no otherThread methods. This is important because classes should not be subclassed unless the programmer intends on modifying or enhancing the fundamental behavior of the class.

采用继承Thread类方式：
（1）优点：编写简单，如果需要访问当前线程，无需使用Thread.currentThread()方法，直接使用this，即可获得当前线程。
（2）缺点：因为线程类已经继承了Thread类，所以不能再继承其他的父类。
采用实现Runnable接口方式：
（1）优点：线程类只是实现了Runable接口，还可以继承其他的类。在这种方式下，可以多个线程共享同一个目标对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
（2）缺点：编程稍微复杂，如果需要访问当前线程，必须使用Thread.currentThread()方法。



1、如果extends Thread后就不能extends其他类了 
2、如果implements Runnable，那还是要将这个对象传到Thread的构造方法中，new出一个线程对象， 
3、implements Runnable能让多个线程共享同一个对象

4、1)一般认为:实现Runnable接口的对象,其着眼点主要含义是:一个计算任务.它代表一个要被其它线程(如:线程池中的线程)执行的任务.着眼点是:交由其它人去完成的一个计算任务.  ---对应着:要做的工作 ；

       2)一般认为:从Thread类继承的含义主要是:一个能执行其它(或自己)的任务的一个线程对象.着眼点是:线程的功能(通过继承来扩展执行其它计算任务的能力)  ---对应着:做工作的工作人员



　　本文标签：Java　

　　在java中可有两种 模式实现多线程，一种是继承Thread类，一种是实现Runnable接口；Thread类是在java.lang包中定义的 。一个类惟独继承了Thread类同时覆写了本类中的run() 步骤就 可以实现多线程操作了，然而一个类不得不继承一个父类，这是此步骤的局限 。

　　下面看例子：

1         package org.thread.demo;

2         class MyThread extends Thread{

3         private Stringname;

4         public MyThread(String name) {

5         super();

6         this.name = name;

7         }

8         public void run(){

9         for(int i=0;i<10;i++){

10     System.out.println("线程开端："+this.name+",i="+i);

11     }

12     }

13     }

14     package org.thread.demo;

15     public class ThreadDemo01 {

16     public static void main(String[] args) {

17     MyThread mt1=new MyThread("线程a");

18     MyThread mt2=new MyThread("线程b");

19     mt1.run();

20     mt2.run();

21     }

22     }

　　然而，此时后果很有法则，先第一个对象执行，而后第二个对象执行，并没有彼此运行 。在JDK的文档中 可以发现，一旦调用start() 步骤，则会通过JVM找到run() 步骤 。下面启动start() 步骤启动线程：

23     package org.thread.demo;

24     public class ThreadDemo01 {

25     public static void main(String[] args) {

26     MyThread mt1=new MyThread("线程a");

27     MyThread mt2=new MyThread("线程b");

28     mt1.start();

29     mt2.start();

30     }

31     };

　　这样程序 可以畸形实现交互式运行 。那么为啥非要 使用start(); 步骤启动多线程呢？

　　在JDK的安装路径下，src.zip是所有的java源程序，通过此代码找到Thread中的start() 步骤的定义， 可以发现此步骤中 使用了private native void start0();其中native 要害字示意 可以调用操作系统的底层函数，那么这样的技术成为JNI技术(javaNativeInterface)

　　Runnable接口

　　在实际开辟中一个多线程的操作很少 使用Thread类，而是通过Runnable接口实现 。

32     public interface Runnable{

33     public void run();

34     }

　　例子：

35     package org.runnable.demo;

36     class MyThread implements Runnable{

37     private String name;

38     public MyThread(String name) {

39     this.name = name;

40     }

41     public void run(){

42     for(int i=0;i<100;i++){

43     System.out.println("线程开端："+this.name+",i="+i);

44     }

45     }

46     };

　　然而在 使用Runnable定义的子类中没有start() 步骤，惟独Thread类中才有 。此时视察Thread类，有一个构造 步骤：public Thread(Runnable targer)此 构造步骤承受Runnable的子类实例，也便是说 可以通过Thread类来启动Runnable实现的多线程 。(start() 可以协调系统的资源)：

47     package org.runnable.demo;

48     import org.runnable.demo.MyThread;

49     public class ThreadDemo01 {

50     public static void main(String[] args) {

51     MyThread mt1=new MyThread("线程a");

52     MyThread mt2=new MyThread("线程b");

53     new Thread(mt1).start();

54     new Thread(mt2).start();

55     }

56     }

　　两种实现 模式的区别和联络：

　　在程序开辟中惟独是多线程确定永远以实现Runnable接口为主，由于实现Runnable接口相比继承Thread类有如下 好处：

·         幸免点继承的局限，一个类 可以继承多个接口 。

·         合适于资源的共享

　　以卖票程序为例，通过Thread类实现：

57     package org.demo.dff;

58     class MyThread extends Thread{

59     private int ticket=10;

60     public void run(){

61     for(int i=0;i<20;i++){

62     if(this.ticket>0){

63     System.out.println("卖票：ticket"+this.ticket--);

64     }

65     }

66     }

67     };

　　下面通过三个线程对象，同时卖票：

68     package org.demo.dff;

69     public class ThreadTicket {

70     public static void main(String[] args) {

71     MyThread mt1=new MyThread();

72     MyThread mt2=new MyThread();

73     MyThread mt3=new MyThread();

74     mt1.start();//每个线程都各卖了10张，共卖了30张票 

75     mt2.start();//但实际惟独10张票，每个线程都卖自己的票 

76     mt3.start();//没有达到资源共享 

77     }

78     }

　　假如用Runnable就 可以实现资源共享，下面看例子：

79     package org.demo.runnable;

80     class MyThread implements Runnable{

81     private int ticket=10;

82     public void run(){

83     for(int i=0;i<20;i++){

84     if(this.ticket>0){

85     System.out.println("卖票：ticket"+this.ticket--);

86     }

87     }

88     }

89     }

90     package org.demo.runnable;

91     public class RunnableTicket {

92     public static void main(String[] args) {

93     MyThread mt=new MyThread();

94     new Thread(mt).start();//同一个mt，然而在Thread中就不 可以，假如用同一 

95     new Thread(mt).start();//个实例化对象mt，就会浮现 异样 

96     new Thread(mt).start();

97     }

98     };

　　固然现在程序中有三个线程，然而一共卖了10张票，也便是说 使用Runnable实现多线程 可以达到资源共享目标 。

　　Runnable接口和Thread中间的联络：

　　public class Thread extends Object implements Runnable

　　发现Thread类也是Runnable接口的子类 。

　　

 


报恩的猫
关注
专栏目录
《java程序设计基础》java的Thread线程类与Runnable接口
qq_45724328的博客
11-23 529
1.利用Thread类的子类来创建线程 利用Thread的子类来创建线程 package yuan; class MyThread extends Thread{ //创建一个Thread的子类MyThread private String who; public MyThread(String str) { //构造方法,用于设置成员变量who who = str; } public void run() { //覆盖Thread类的run()方法 for(int i =0;i<5;i+
Java多线程extends Thread和implements Runnable
jc_benben的专栏
05-16 1163
第一种:将类声明为Thread的子类。该子类重写Thread类的run方法，之后就可以分配并且启动该子类的实例。 第二种：声明实现Runnable的接口类。在该类实现run()方法，然后分配该类实例，之后创建Thread时作为一个参数传递并启动即可。Runnable为非Thread子类的类提供了一种激活的方式。因为接口实现的Thread的接口类并不是线程，所以使用的时候要先创建该类然后创建线程并把该类对象传进创建的线程类。 class ThreadDemo extends Thread/implemen
public class TableBcpProcessor extends Thread
studyvcmfc的专栏
07-01 1231
<br />public class TableBcpProcessor extends Thread<br />{<br />    private static DebugPrn dMsg = new DebugPrn(TableBcpProcessor.class.getName());<br />    private DatabaseInfo dbInfo = null;<br />    private String dbName = null;<br />    private String[
Java进阶（5）——创建多线程的方法extends Thread和implements Runnable的对比 & 线程池及常用的线程池
Arya的博客，专注后端领域
08-22 1417
1.创建多线程两种方法，继承thread，实现runnable，常用runnable； 2.线程池，管理线程，控制并发； 3.常用的线程池，newFixedThreadPool定容量； 4.newCachedThreadPool容量大，Integer.MAX_VALUE； 5.newScheduledThreadPool（定时任务），newSingleThreadScheduledExecutor单线程的线程池的定时任务； 6.newSingleThreadExecutor（单线程），单线程的线程池；
java 多线程Thread与runnable的区别
08-29
Java 多线程 Thread 与 Runnable 的区别 Java 多线程技术是 Java 语言中的一种基础技术，用于实现多任务并发执行的功能。在 Java 中，实现多线程有两种方法：继承 Thread 类和实现 Runnable 接口。在本文中，我们将...
java个人学习笔记16（多线程+extends Thread+implements Runnable）
......
03-22 1282
1.多线程 进程：正在运行的应用程序在内存中分配的空间 线程：是进程中负责程序执行的执行单元，也称执行路径  一个进程中至少有一个线程在负责该进程的运行 多线程技术：解决多部分代码同时执行的需求，合理使用cpu资源，提高用户体验。（微观上串行，并未实际上提高效率） 多线程的运行是根据cpu的切换完成的，具有不确定性。 jvm中的多线程（至少2个）：一个负责代码的运行，这个从main方法
设有T、R类声明如下，说明怎样使用这些实例创建、启动线程并执行有效操作？ public class T extends Thread public class R implements Runnable
10-08
在Java中，你可以通过以下步骤使用`Thread`类和`Runnable`接口来创建、启动线程并执行有效操作： 1. **使用Thread类**: 如果你选择直接继承`Thread`类，可以这样做： ```java public class YourClass extends ...
设有T、R类声明如下，说明怎样使用这些实例创建、启动线程并执行有效操作？ public class T extends Thread public class R implements Runnable
最新发布
10-08
public class T extends Thread { @Override public void run() { // 实现具体的线程任务 // 示例： System.out.println("Running in thread " + this.getName()); // ... } } // 创建T类的实例，并启动线程...
线程同步（线程安全问题）、等待和唤醒、线程池、Lambda、
于小猿的博客
09-07 451
1、线程同步（线程安全问题） （1）解决线程安全问题的第一种方案：使用同步代码块 好处：解决了线程安全问题 缺点：程序频繁的判断锁，获取锁，释放锁，程序的效率会降低 a）定义一个Runnable接口的实现类，用于创建Runnable接口实现类对象 package com.itheima.demo05Synchronized; //解决线程安全问题的一种方案：使用同步代码块，把同步代码块锁住，只让一个线程在同步代码块中执行 public class RunnableImpl implements
牛客网刷题day02
oldwangold的博客
02-26 331
1.JDK所提供的StringBuilder、StringBuffer就是为了照顾单线程环境和多线程环境所提供的类，在单线程环境下应该使用StringBuilder来保证更好的性能；当需要保证多线程安全时，就应该使用StringBuffer。  2.下面关于Java类的构造方法的说法中正确的是：（ ） 一个类至少有一个构造方法 构造方法的返回值类型必须是void（错误） ...
java创建线程implement runnable 和 extends thread 比较
Great_Smile的专栏
12-31 7696
我们都知道java实现线程有两种方法 一。继承Thread类 二。实现Runnable接口 我们知道从代码上看 第二种方法扩张性更好，因为java的单继承特性 看到很多说法他们之间有一个区别是：实现Runnable接口才能实现资源共享。 并且附有类似一下的实例： //Implement Runnable Interface... class ImplementsRunnab
Java多线程（一）线程的创建
hewenhaoxiansen的博客
05-12 158
Java创建线程的方式有两种 ①继承Thread类重写run（）方法 /** * Created by hewenhao on 2020/5/12 * Description 线程创建方式-：继承Thread类，重写run（）方法 */ public class ExtendsThread extends Thread{ @Override public void run() { System.out.println("线程id：" + Thread.curr
Java中继承Thread和实现Runnable这两种创建线程有何区别
java学习笔记
06-26 999
Java中线程的创建有两种方式： 1． 通过继承Thread类，重写Thread的run()方法，将线程运行的逻辑放在其中 2． 通过实现Runnable接口，实例化Thread类 在实际应用中，我们经常用到多线程，如车站的售票系统，车站的各个售票口相当于各个线程。当我们做这个系统的时候可能会想到两种方式来实现，继承Thread类或实现Runnable接口，现在看一下这两种方式实现的两种
一文搞懂Java多线程
Systemmax20的博客
07-02 656
一文搞懂Java多线程的运行机制，包括Java多线程创建、生命周期、线程调度、线程同步等。
Java 中的“implements Runnable” 和“extends Thread”
didingyun4257的博客
09-18 424
知识点 “implements Runnable” 和“extends Thread”的不同 具体分析 最近在学习Android中的Handler消息传递机制时，创建新线程有两种方式：一种是实现Runnable接口（implements Runnable）而另一种则是继承Threa...
Java多线程系列—多线程的实现方式(01)
热门推荐
04-30 6万+
多线程的实现方式 实现线程是并发编程中基础中的基础，因为我们必须要先实现线程，才可以继续后续的一系列操作。 基本实现方式 Runable public class ImplementRunable implements Runnable { @Override public void run() { while (true) { // 输出线程的名字，与主线程名称相区分 System.out.println(Thread.cur
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值