Runnable接口与Thread类的区别

Runnable接口与Thread类的区别

     本以为runnable接口和thread类的区别不大，看了一个实例是用thread实现多个client和server通信，我就把thread改为了runable接口来实现，开始总不对。报错是一直有空值。

    原来，接口中时不能有构造函数，所以，当你使用接口的时候，就没有办法通过使用构造函数来传递变量，当我显示的用构造函数来声明一个对象时，这个构造函数根本就没有被执行。然而，thread就可以，因为它是直接的java类。

    下面是在又在网上具体查了一下：

    如果让一个线程实现Runnable接口，那么当调用这个线程的对象开辟多个线程时，可以让这些线程调用同一个变量；若这个线程是由继承Thread类而来，则要通过内部类来实现上述功能，利用的就是内部类可任意访问外部变量这一特性。 

例子程序：Java代码

1. public class ThreadTest {   
2.   
3.     public static void main(String[] args) {   
4.          MyThread mt = new MyThread();   
5.         new Thread(mt).start(); //通过实现Runnable的类的对象来开辟第一个线程  
6.         new Thread(mt).start(); //通过实现Runnable的类的对象来开辟第二个线程  
7.         new Thread(mt).start(); //通过实现Runnable的类的对象来开辟第三个线程  
8.         //由于这三个线程是通过同一个对象mt开辟的，所以run()里方法访问的是同一个index  
9.      }   
10. }   
11.   
12. class MyThread implements Runnable { //实现Runnable接口  
13.        
14.     int index = 0;   
15.        
16.     public void run() {   
17.         for(;index <= 200;)   
18.              System.out.println(Thread.currentThread().getName() + ":" + index++);   
19.      }   
20. }  

public class ThreadTest 

{

 public static void main(String[] args)

 { MyThread mt = new MyThread(); 

new Thread(mt).start(); //通过实现Runnable的类的对象来开辟第一个线程

new Thread(mt).start(); 

//通过实现Runnable的类的对象来开辟第二个线程

 new Thread(mt).start(); //通过实现Runnable的类的对象来开辟第三个线程

 //由于这三个线程是通过同一个对象mt开辟的，所以run()里方法访问的是同一个index }

}

class MyThread implements Runnable

 {

 //实现Runnable接口 

int index = 0; 

public void run()

 {

 for(;index <= 200;) 

System.out.println(Thread.currentThread().getName() + ":" + index++); 

}

}

运行结果： 

Java代码

1. Thread-0:0  
2. Thread-2:1  
3. Thread-2:2  
4. Thread-2:3  
5. Thread-2:4  
6. Thread-2:5  
7. Thread-2:6  
8. Thread-2:7  
9. Thread-2:8  
10. Thread-2:9  
11. Thread-2:10  
12. Thread-2:11  
13. Thread-2:12  
14. Thread-2:13  
15. Thread-2:14  
16. Thread-2:15  
17. Thread-2:16  
18. Thread-2:17  
19. Thread-0:18  
20. Thread-1:19  
21. Thread-0:20  

Java代码

1. public class ThreadTest {   
2.   
3.     public static void main(String[] args) {   
4.            
5.          MyThread mt=new MyThread();   
6.          mt.getThread().start(); //通过返回内部类的对象来开辟第一个线程  
7.          mt.getThread().start(); //通过返回内部类的对象来开辟第二个线程  
8.          mt.getThread().start(); //通过返回内部类的对象来开辟第三个线程  
9.         //由于这三个线程是通过同一个匿名对象来开辟的，所以run()里方法访问的是同一个index  
10.      }   
11. }   
12.   
13. class MyThread {   
14.        
15.     int index = 0;   
16.        
17.     private class InnerClass extends Thread { //定义一个内部类，继承Thread  
18.   
19.         public void run() {   
20.             for(; index <= 200;)   
21.                  System.out.println(getName() + ":" + index++);   
22.          }   
23.      }   
24.        
25.      Thread getThread() { //这个函数的作用是返回InnerClass的一个匿名对象  
26.         return new InnerClass();   
27.      }   
28. }  

public class ThreadTest 

{ 

public static void main(String[] args)

{ 

MyThread mt=new MyThread(); 

mt.getThread().start(); //通过返回内部类的对象来开辟第一个线程 

mt.getThread().start(); //通过返回内部类的对象来开辟第二个线程 

mt.getThread().start(); //通过返回内部类的对象来开辟第三个线程 

//由于这三个线程是通过同一个匿名对象来开辟的，所以run()里方法访问的是同一个index 

}

}

class MyThread

 {

 int index = 0;

 private class InnerClass extends Thread

 {

 //定义一个内部类，继承Thread public void run() 

{

 for(; index <= 200;) 

System.out.println(getName() + ":" + index++);

 }

 } 

Thread getThread()

 {

 //这个函数的作用是返回InnerClass的一个匿名对象

 return new InnerClass();

 }

}

这里有一个问题：如果内部类要访问一个外部变量或方法，那么这个变量或方法必须定义为final，但为什么这里的变量index不用定义为final就可以被内部类访问？