Java中Runnable和Thread的区别

转载 2015年11月17日 16:09:48


http://blog.chinaunix.net/uid-20665441-id-310538.html

线程的起动并不是简单的调用了你的RUN方法,而是由一个线程调度器来分别调用你的所有线程的RUN方法,
我们普通的RUN方法如果没有执行完是不会返回的,也就是会一直执行下去,这样RUN方法下面的方法就不可能会执行了,可是线程里的RUN方法却不一样,它只有一定的CPU时间,执行过后就给别的线程了,这样反复的把CPU的时间切来切去,因为切换的速度很快,所以我们就感觉是很多线程在同时运行一样.

你简单的调用run方法是没有这样效果的,所以你必须调用Thread类的start方法来启动你的线程.所以你启动线程有两种方法
一是写一个类继承自Thread类,然后重写里面的run方法,用start方法启动线程
二是写一个类实现Runnable接口,实现里面的run方法,用new Thread(Runnable target).start()方法来启动

这两种方法都必须实现RUN方法,这样线程起动的时候,线程管理器好去调用你的RUN方法.

你的TestThread没有继承自Thread类,怎么可能会有start方法呢?



在java中可有两种方式实现多线程,一种是继承Thread类,一种是实现Runnable接口;

Thread类是在java.lang包中定义的。一个类只要继承了Thread类同时覆写了本类中的

run()方法就可以实现多线程操作了,但是一个类只能继承一个父类,这是此方法的局限,

下面看例子:

  package org.thread.demo;

  class MyThread extends Thread{

  private String name;

  public MyThread(String name) {

  super();

  this.name = name;

  }

  public void run(){

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

  System.out.println("线程开始:"+this.name+",i="+i);

  }

  }

  }

  package org.thread.demo;

  public class ThreadDemo01 {

  public static void main(String[] args) {

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

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

      // thread1,thread2,按顺序进行

  mt1.run();

  mt2.run();

  }

  }

  但是,此时结果很有规律,先第一个对象执行,然后第二个对象执行,并没有相互运行。在JDK的文档中可以发现,一旦调用start()方法,则会通过JVM找到run()方法。下面启动

  start()方法启动线程:

  package org.thread.demo;

  public class ThreadDemo01 {

  public static void main(String[] args) {

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

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

  //乱序进行

      mt1.start();

  mt2.start();

  }

  };

      这样程序可以正常完成交互式运行。那么为啥非要使用start()方法启动多线程呢?

  在JDK的安装路径下,src.zip是全部的java源程序,通过此代码找到Thread中的start()方法的定义,可以发现此方法中使用了private native void start0();其中native关键字表示可以调用操作系统的底层函数,那么这样的技术成为JNI技术(java Native Interface)

  ·Runnable接口

  在实际开发中一个多线程的操作很少使用Thread类,而是通过Runnable接口完成。

  public interface Runnable{

  public void run();

  }

  例子:

  package org.runnable.demo;

  class MyThread implements Runnable{

  private String name;

  public MyThread(String name) {

  this.name = name;

  }

  public void run(){

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

  System.out.println("线程开始:"+this.name+",i="+i);

  }

  }

  };


但是在使用Runnable定义的子类中没有start()方法,只有Thread类中才有。此时观察Thread类,有一个构造方法:public Thread(Runnable target)

  此构造方法接受Runnable的子类实例,也就是说可以通过Thread类来启动Runnable实现的多

  线程。(start()可以协调系统的资源):

  package org.runnable.demo;

  import org.runnable.demo.MyThread;

  public class ThreadDemo01 {

  public static void main(String[] args) {

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

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

  new Thread(mt1).start();

  new Thread(mt2).start();

  }

  }

  · 两种实现方式的区别和联系:

  在程序开发中只要是多线程肯定永远以实现Runnable接口为主,因为实现Runnable接口相比

  继承Thread类有如下好处:

  ->避免点继承的局限,一个类可以继承多个接口。

  ->适合于资源的共享

  以卖票程序为例,通过Thread类完成:

  package org.demo.dff;

  class MyThread extends Thread{

  private int ticket=10;

  public void run(){

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

  if(this.ticket>0){

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

  }

  }

  }

  };

  下面通过三个线程对象,同时卖票:

  package org.demo.dff;

  public class ThreadTicket {

  public static void main(String[] args) {

  MyThread mt1=new MyThread();

  MyThread mt2=new MyThread();

  MyThread mt3=new MyThread();

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

  mt2.start();//但实际只有10张票,每个线程都卖自己的票

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

  }

  }

  如果用Runnable就可以实现资源共享,下面看例子:

  package org.demo.runnable;

  class MyThread implements Runnable{

  private int ticket=10;

  public void run(){

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

  if(this.ticket>0){

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

  }

  }

  }

  }

  package org.demo.runnable;

  public class RunnableTicket {

  public static void main(String[] args) {

  MyThread mt=new MyThread();

  new Thread(mt).start();//同一个mt,但是在Thread中就不可以,如果用同一

  new Thread(mt).start();//个实例化对象mt,就会出现异常

  new Thread(mt).start();

  }

  };

  虽然现在程序中有三个线程,但是一共卖了10张票,也就是说使用Runnable实现多线程可以达到资源共享目的。

  Runnable接口和Thread之间的联系:

  public class Thread extends Object implements Runnable

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

JAVA多线程之Runnable和Thread比较

在我们开发的过程中常常会碰到多线程的问题,对于多线程的实现方式主要有两种:实现Runnable接口、继承Thread类。对于这两种多线程的实现方式也是有着一些差异。既然实现了多线程那必然离不开管理这些...
  • u013755987
  • u013755987
  • 2016年07月11日 21:15
  • 10491

Java中 Thread和Runnable实现多线程的区别和联系

Java有两种方式实现多线程,第一个是继承Thread类,第二个是实现Runnable接口。他们之间的联系: 1、Thread类实现了Runable接口。 2、都需要重写里面Run方法。 他们之间的区...
  • oxuanboy1
  • oxuanboy1
  • 2016年06月22日 12:18
  • 2246

Java中Runnable和Thread以及Callable的区别

在java中,其实java中实现 多线程有三种方法,一种是继承Thread类;第二种是实现Runnable接口;第三种是实现Callable接口。1,继承Thread        Thread类是在...
  • huang211630
  • huang211630
  • 2015年05月11日 08:08
  • 2643

java线程系列---Runnable和Thread的区别、线程同步

Runnable和Thread的区别原文 线程锁原文 鉴于我这篇文章被鄙视了,哈哈哈哈。我决定整理一下资源共享线程同步相关的知识。欢迎鄙视并谈一谈见解。 Java传统多线程的...
  • guoxiaolongonly
  • guoxiaolongonly
  • 2016年02月22日 16:19
  • 2914

Thread 和 Runnable 的区别

Thread 和 Runnable 的区别 实际上,Thread也是一个Runnable,它实现了Runnable接口,在Thread类中有一个Runnable类型的target字段,代表要被执...
  • import_sadaharu
  • import_sadaharu
  • 2016年08月03日 23:42
  • 3233

Runnable接口与Thread类的区别

什么时候让线程实现Runnable接口,什么时候让线程继承Thread类? JDK帮助文档中的原话:Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现 (不明白是啥意思) 孙鑫...
  • colder2008
  • colder2008
  • 2013年12月27日 17:35
  • 1574

Thread类与Runnable接口的区别

Java中线程的创建有两种方式:   1.  通过继承Thread类,重写Thread的run()方法,将线程运行的逻辑放在其中 2.  通过实现Runnable接口,实例化Thread类     ...
  • shenxiaoming77
  • shenxiaoming77
  • 2014年02月13日 10:34
  • 1501

【Java并发编程】之六:Runnable和Thread实现多线程的区别(含代码)

Java中实现多线程有两种方法:继承Thread类、实现Runnable接口,在程序开发中只要是多线程,肯定永远以实现Runnable接口为主,因为实现Runnable接口相比继承Thread类有如下...
  • mmc_maodun
  • mmc_maodun
  • 2013年12月06日 10:15
  • 37568

android之Runnable与Thread的区别详解

在java中可有两种方式实现多线程,一种是继承Thread类,一种是实现Runnable接口;Thread类是在java.lang包中定义的。一个类只要继承了Thread类同时覆写了本类中的run()...
  • zhongwn
  • zhongwn
  • 2014年04月22日 17:38
  • 612

多线程——Java中继承Thread类与实现Runnable接口的区别

线程我只写过继承Thread类的,后来知道java多线程有三种方式,今天首先比较一下常用的继承Thread类和实现Runnable接口的区别。               按着Ctrl键进入Threa...
  • xdd19910505
  • xdd19910505
  • 2016年02月24日 18:27
  • 5856
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Java中Runnable和Thread的区别
举报原因:
原因补充:

(最多只允许输入30个字)