java中runnable和thread的区别-ag真人游戏

runnable 是接口。

thread 是类，且实现了runnable接口。

thread部分源码

[java]  view plain  copy

1. public class thread  
2.     implements runnable  
3. {  
4.     private static class caches  
5.     {  
6.   
7.         static final concurrentmap subclassaudits = new concurrenthashmap();  
8.         static final referencequeue subclassauditsqueue = new referencequeue();  

在使用runnable定义的子类中没有start()方法，只有thread类中才有。

[java]  view plain  copy

1. public interface runnable  
2. {  
3.   
4.     public abstract void run();  
5. }  

thread类，有一个构造方法：public thread(runnable targer)

[java]  view plain  copy

1. public thread(runnable runnable)  
2. {  
3.     daemon = false;  
4.     stillborn = false;  
5.     threadlocals = null;  
6.     inheritablethreadlocals = null;  
7.     threadstatus = 0;  
8.     blockerlock = new object();  
9.     init(null, runnable, (new stringbuilder()).append("thread-").append(nextthreadnum()).tostring(), 0l);  
10. }  

此构造方法接受runnable的子类实例，也就是说可以通过thread类来启动runnable实现的多线程。

在程序开发中只要是多线程肯定永远以实现runnable接口为主。

实现runnable接口相比继承thread类有如下好处：
1、避免继承的局限，一个类可以继承多个接口。
2、适合于资源的共享。

以卖票为例，总共只有10张动车票了，全国3个窗口在卖。

继承thread类的方法

[java]  view plain  copy

1. package multithreading;  
2.   
3. public class mythreadwithextends extends thread {  
4.   
5.     private int tickets = 10;  
6.   
7.     @override  
8.     public void run() {  
9.   
10.         for (int i = 0; i <= 100; i ) {  
11.             if(tickets>0){  
12.                 system.out.println(thread.currentthread().getname() "--卖出票："   tickets--);  
13.             }  
14.         }  
15.     }  
16.       
17.       
18.     public static void main(string[] args) {  
19.         mythreadwithextends thread1 = new mythreadwithextends();  
20.         mythreadwithextends thread2 = new mythreadwithextends();  
21.         mythreadwithextends thread3 = new mythreadwithextends();  
22.   
23.         thread1.start();  
24.         thread2.start();  
25.         thread3.start();  
26.           
27.         //每个线程都独立，不共享资源，每个线程都卖出了10张票，总共卖出了30张。如果真卖票，就有问题了。  
28.     }  
29.   
30. }  

运行结果：

thread-0--卖出票：10
thread-2--卖出票：10
thread-1--卖出票：10
thread-2--卖出票：9
thread-0--卖出票：9
thread-2--卖出票：8
thread-1--卖出票：9
thread-2--卖出票：7
thread-0--卖出票：8
thread-2--卖出票：6
thread-2--卖出票：5
thread-2--卖出票：4
thread-1--卖出票：8
thread-2--卖出票：3
thread-0--卖出票：7
thread-2--卖出票：2
thread-2--卖出票：1
thread-1--卖出票：7
thread-0--卖出票：6
thread-1--卖出票：6
thread-0--卖出票：5
thread-0--卖出票：4
thread-1--卖出票：5
thread-0--卖出票：3
thread-1--卖出票：4
thread-1--卖出票：3
thread-1--卖出票：2
thread-0--卖出票：2
thread-1--卖出票：1
thread-0--卖出票：1

每个线程都独立，不共享资源，每个线程都卖出了10张票，总共卖出了30张。如果真卖票，就有问题了。

实现runnable接口方式

[java]  view plain  copy

1. package multithreading;  
2.   
3. public class mythreadwithimplements implements runnable {  
4.   
5.     private int tickets = 10;  
6.   
7.     @override  
8.     public void run() {  
9.   
10.         for (int i = 0; i <= 100; i ) {  
11.             if(tickets>0){  
12.                 system.out.println(thread.currentthread().getname() "--卖出票："   tickets--);  
13.             }  
14.         }  
15.     }  
16.       
17.       
18.     public static void main(string[] args) {  
19.         mythreadwithimplements myrunnable = new mythreadwithimplements();  
20.         thread thread1 = new thread(myrunnable, "窗口一");  
21.         thread thread2 = new thread(myrunnable, "窗口二");  
22.         thread thread3 = new thread(myrunnable, "窗口三");  
23.   
24.         thread1.start();  
25.         thread2.start();  
26.         thread3.start();  
27.     }  
28.   
29. }  

运行结果：

窗口二--卖出票：10
窗口三--卖出票：9
窗口一--卖出票：8
窗口三--卖出票：6
窗口三--卖出票：4
窗口三--卖出票：3
窗口三--卖出票：2
窗口三--卖出票：1
窗口二--卖出票：7
窗口一--卖出票：5

每个线程共享了对象myrunnable的资源，卖出的总票数是对的，但是顺序是乱的，怎么办？