java中Thread与Runnable的区别

在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);

        }

}

    public class threaddemo01 {

       public static void main(string[] args) {

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

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

           mt1.run(); 

           mt2.run();

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

start()方法启动线程：

public class threaddemo01 {

    public static void main(string[] args) {

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

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

        mt1.start();

        mt2.start();

};

使用start才能正确启动现成，使用run只是方法调用。

这样程序可以正常完成交互式运行。那么为啥非要使用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{

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

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

但是在使用runnable定义的子类中没有start()方法，只有thread类中才有。此时观察thread类，有一个构造方法：public thread(runnable targer)

此构造方法接受runnable的子类实例，也就是说可以通过thread类来启动runnable实现的多线程。（start()可以协调系统的资源）:

import org.runnable.demo.mythread;

        public static void main(string[] args) {

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

            new thread(mt1).start();

            new thread(mt2).start();

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

在程序开发中只要是多线程肯定永远以实现runnable接口为主，因为实现runnable接口相比继承thread类有如下好处

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

适合于资源的共享

以卖票程序为例，通过thread类完成：

package org.demo.dff;

    private int ticket=10;

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

            if(this.ticket>0){

                system.out.println("賣票：ticket"+this.ticket--);

            }

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

public class threadticket {

        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;

public class runnableticket {

        mythread mt=new mythread();

        new thread(mt).start(); 

        new thread(mt).start();

        new thread(mt).start();

同一个mt，但是在thread中就不可以，如果用同一个实例化对象mt，就会出现异常 

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

runnable接口和thread之间的联系

public class thread extends object implements runnable 发现thread类也是runnable接口的子类

原帖地址:http://www.cnblogs.com/freeliver54/archive/2011/09/26/2191266.html