黑马程序员技术交流社区

标题: Runnable接口疑问？ [打印本页]

作者: 梁健生 时间: 2013-11-20 08:11
标题: Runnable接口疑问？
Runnable接口的主要用途是什么？在什么情况下用Runnable接口？

作者: hubby 时间: 2013-11-20 08:17
实现runable接口可以复写run方法，然后Thread类中有个构造函数可以接受runable类。从而可以创建多线程，不用直接继承thread来复写run方法创建多线程了。因为java只支持单继承，所以你实现了runable又可以有多线程，又可以去继承其他的类，两全其美

作者: ┾——黑马 时间: 2013-11-20 08:39
在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接口的子类。

作者: 王雨神 时间: 2013-11-20 09:00
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命令执行一个类的时候，实际上都会启动一个ＪＶＭ，每一个ｊＶＭ实习在就是在操作系统中启动了一个进程。

作者: 黄炳期 时间: 2013-11-20 09:17
帖子已分类，若仍有疑惑，可重新提问

作者: 木木赤赤 时间: 2013-11-20 09:27
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方法。

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2