A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 梁健生 中级黑马   /  2013-11-20 08:11  /  1353 人查看  /  5 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

Runnable接口的主要用途是什么?在什么情况下用Runnable接口?

评分

参与人数 1技术分 +1 收起 理由
黄炳期 + 1

查看全部评分

5 个回复

倒序浏览
实现runable接口可以复写run方法,然后Thread类中有个构造函数可以接受runable类。从而可以创建多线程,不用直接继承thread来复写run方法创建多线程了。因为java只支持单继承,所以你实现了runable又可以有多线程,又可以去继承其他的类,两全其美

评分

参与人数 1技术分 +1 收起 理由
黄炳期 + 1

查看全部评分

回复 使用道具 举报
在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");  
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 targer)此构造方法接受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接口的子类。

评分

参与人数 1技术分 +1 收起 理由
黄炳期 + 1

查看全部评分

回复 使用道具 举报
   java中线程的创建有俩中方法。

第一种是继承Thread类。重写run方法,然后NEW对象,调用对象的start()方法。该方法有俩个作用:启动线程,调用run方法。


[java] view plaincopy
package com.itheima;  
class TestThread2 extends Thread {  
    String name;  
    TestThread2(){}  
    TestThread2(String name){  
        this.name=name;  
    }  
    /**
     * @param args
     */  
    public void run(){  
        for(int i=0;i<100;i++){  
  
            if(name!=null){  
                System.out.println(name+"......"+i);  
            }else{  
                System.out.println(i);  
            }  
        }  
    }  
  
}  
public class TestThread1 {  
  
    /**
     * @param args
     */  
    public static void main(String[] args) {  
        // TODO Auto-generated method stub  
        TestThread2 th1=new TestThread2("th1");  
        TestThread2 th2=new TestThread2();  
        th1.start();  
        th2.start();  
    }  
  
}  

这个例子的运行结果为:俩个线程同时执行,抢夺CPU的执行权,谁抢到就执行谁。打印数据的结果为:打印线程1一会,打印线程2一会。交替执行。
这里有个容易犯错的地方:就是直接用TestThread2对象调用run()方法,很多同学以为一样。

那么我们把上例中

th1.start()

th2.start()


改为


th1.run()

th2.run()


通过例子我们发现,直接调用run()方法的话,我们发现则不能启动多线程,也就是说th1.run()方法不执行完毕,不会调用他下面的th2.run()方法。这俩个线程成了一个线程。










第二种方法是实现Runnable接口,重写run方法,创建Thread对象的时候把实现Runnable接口的对象作为参数传进去,然后Thread对象调用start()方法启动线程。


[java] view plaincopy
package com.itheima;  
class TestThread2 implements Runnable {  
    String name;  
    TestThread2(){}  
    TestThread2(String name){  
        this.name=name;  
    }  
    /**
     * @param args
     */  
    public void run(){  
        for(int i=0;i<100;i++){  
  
            if(name!=null){  
                System.out.println(name+"......"+i);  
            }else{  
                System.out.println(i);  
            }  
        }  
    }  
  
}  
public class TestThread1 {  
  
    /**
     * @param args
     */  
    public static void main(String[] args) {  
        // TODO Auto-generated method stub  
         
        TestThread2 th1=new TestThread2("th1");  
        TestThread2 th2=new TestThread2("th2");  
        Thread      t1=new Thread(th1);  
        Thread      t2=new Thread(th2);  
        t1.start();  
        t2.start();  
    }  
  
}  
<span style="font-family: Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace; background-color: rgb(255, 255, 255); ">     </span>  


俩中方法都可以创建线程,那么这俩中方法的区别是什么呢?

继承Thread类创建线程则不适合资源共享,而实现了Runnable接口则很容易。


[java] view plaincopy
/**
* @author Rollen-Holt 继承Thread类,不能资源共享
* */  
class hello extends Thread {  
    public void run() {  
        for (int i = 0; i < 7; i++) {  
            if (count > 0) {  
                System.out.println("count= " + count--);  
            }  
        }  
    }  
   
    public static void main(String[] args) {  
        hello h1 = new hello();  
        hello h2 = new hello();  
        hello h3 = new hello();  
        h1.start();  
        h2.start();  
        h3.start();  
    }  
   
    private int count = 5;  
}  
【运行结果】:

count= 5

count= 4

count= 3

count= 2

count= 1

count= 5

count= 4

count= 3

count= 2

count= 1

count= 5

count= 4

count= 3

count= 2

count= 1


通过打印结果我们看到资源并没有共享,那么实现Runnable接口呢?我们来看一个买票系统的例子。


[java] view plaincopy
class MyThread implements Runnable{  
   
    private int ticket = 5;  //5张票  
   
    public void run() {  
        for (int i=0; i<=20; i++) {  
            if (this.ticket > 0) {  
                System.out.println(Thread.currentThread().getName()+ "正在卖票"+this.ticket--);  
            }  
        }  
    }  
}  
public class lzwCode {  
      
    public static void main(String [] args) {  
        MyThread my = new MyThread();  
        new Thread(my, "1号窗口").start();  
        new Thread(my, "2号窗口").start();  
        new Thread(my, "3号窗口").start();  
    }  
}  

运行结果:
1号窗口正在卖票5

1号窗口正在卖票3


1号窗口正在卖票4


1号窗口正在卖票2


1号窗口正在卖票1






总结:

实现Runnable接口对比继承Thread类所具有的优势:

1):适合多个相同的程序代码的线程去处理同一个资源

2):可以避免java中的单继承的限制

3):增加程序的健壮性,代码可以被多个线程共享,代码和数据独立。



所以,本人建议大家尽量实现Runnable接口的方法去创建线程。





提醒一下大家:main方法其实也是一个线程。在java中所以的线程都是同时启动的,至于什么时候,哪个先执行,完全看谁先得到CPU的执行权。



在java中,每次程序运行至少启动2个线程。一个是main线程,一个是垃圾收集线程。因为每当使用java命令执行一个类的时候,实际上都会启动一个JVM,每一个jVM实习在就是在操作系统中启动了一个进程。

评分

参与人数 1技术分 +1 收起 理由
黄炳期 + 1 很给力!

查看全部评分

回复 使用道具 举报
帖子已分类,若仍有疑惑,可重新提问
回复 使用道具 举报
Runnable接口中只定义了一个方法,即为run方法
void run()
使用实现接口 Runnable 的对象创建一个线程时,启动该线程将导致在独立执行的线程中调用对象
的 run 方法。
方法 run 的常规协定是,它可能执行任何所需的动作。


创建线程的二种方式之一:实现Runable接口
步骤:
1,定义类实现Runnable接口
2,覆盖Runnable接口中的run方法。
将线程要运行的代码存放在该run方法中。
3,通过Thread类建立线程对象。
4,将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
为什么要将Runnable接口的子类对象传递给Thread的构造函数。
因为,自定义的run方法所属的对象是Runnable接口的子类对象。
所以要让线程去指定指定对象的run方法。就必须明确该run方法所属对象。
5,调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马