我們都知道java實現執行緒有兩種方法

一。繼承Thread類

二。實現Runnable介面

看到很多說法他們之間有一個區別是：實現Runnable接口才能實現資源共享。繼承thread的方式不行

並且附有類似以下的例項：

//Implement Runnable 的方式來實現執行緒classImplementsRunnableimplementsRunnable{privateint counter =0;publicvoid run(){
    counter++;System.out.println("ImplementsRunnable : Counter : "+ counter);
 
}}//通過繼承 Thread 類的方式classExtendsThreadextendsThread{privateint counter =0;publicvoid run(){
    counter++;System.out.println("ExtendsThread : Counter : "+ counter);}}publicclassThreadVsRunnable{publicstaticvoid main(String args[])throwsException{// 多執行緒共享同一個變數（rc）ImplementsRunnable rc =newImplementsRunnable
 
();Thread t1 =newThread(rc);
    t1.start();Thread.sleep(1000);//啟動下一個執行緒前，等待一秒鐘Thread t2 =newThread(rc);
    t2.start();Thread.sleep(1000);//啟動下一個執行緒前，等待一秒鐘Thread t3 =newThread(rc);
    t3.start();// 通過extend Thread只能為每一個執行緒建立新的物件ExtendsThread tc1 =newExtendsThread();
    tc1.start();Thread.sleep(1000);ExtendsThread
 
 tc2 =newExtendsThread();
    tc2.start();Thread.sleep(1000);ExtendsThread tc3 =newExtendsThread();
    tc3.start();}}

輸出結果如下：

ImplementsRunnable:Counter:1ImplementsRunnable:Counter:2ImplementsRunnable:Counter:3ExtendsThread:Counter:1ExtendsThread:Counter:1ExtendsThread:Counter:1

他們通過這個例子得出：實現Runnable接口才能實現資源共享。繼承thread的方式不行 這個結論

其實我們仔細看一下這個例子，就會發現這個結論是錯的：

1.首先我們看一下通過 Implements Runnable 方式建立執行緒時，發生了什麼

擷取上面例子中的兩行程式碼：

ImplementsRunnable rc = new ImplementsRunnable();
Thread t1 = new Thread(rc);

我們進入Thread類的原始碼看一下（經過簡化,要檢視完整方法，參看java原始碼）：

當new Thread的時候，會呼叫Thread的init()方法，初始化這個執行緒

/**
     * 初始化一個Thread
     * .......
     * @引數 target ：這個target引數的run()方法將會被最後呼叫（the object whose run() method gets called）
     * ........
     */
    private void init(...,Runnable target,....) {
	......
	this.target = target;
	......
    }

    public void run() {
	if (target != null) {
	    target.run();
	}
    }

我們可以看到正如前面init()方法的註釋所描述的一樣，最終會呼叫的是線程init()時傳遞給這個Thread的target引數的run方法。

所以正如一開始的例子中的程式碼那樣，用同一個Runnable target初始化多個執行緒，那麼這多個執行緒都會呼叫同一個target的run()方

法。至始至終這個ImplementsRunnable物件就只有一個。

在這裡要加一段話 雖然這樣實現了資源的共享，但是並沒有實現資源的同步，如下例子，我加入一個條件，如果counter小於10才能繼續+1（比如多個視窗同時賣火車票的場景）：

class ImplementsRunnable implements Runnable {
		private int counter = 0;
		public void run() {
			while(counter<10){
				counter++;
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
				}
				System.out.println(Thread.currentThread().getName()+":"+ counter);
			}
		}
}

public static void main(String args[]) throws Exception {
		  // Multiple threads share the same object.
		  ImplementsRunnable rc = new ImplementsRunnable();
		  Thread t1 = new Thread(rc);
		  t1.start();
		  Thread.sleep(1000); // Waiting for 1 second before starting next thread
		  Thread t2 = new Thread(rc);
		  t2.start();
		  Thread.sleep(1000); // Waiting for 1 second before starting next thread
		  Thread t3 = new Thread(rc);
		  t3.start();
		}

Thread-5:2
Thread-6:3
Thread-5:4
Thread-5:6
Thread-6:7
Thread-7:8
Thread-5:9
Thread-6:10
Thread-7:9
Thread-5:10

修改後的程式碼如下：

class ImplementsRunnable implements Runnable {
		private int counter = 0;
		public void run() {
			while(counter<10){
				synchronized(this){
					if(counter<10){
						counter++;
						System.out.println(Thread.currentThread().getName()+":"+ counter);
					}
				}
			}
		}
}

Thread-5:1
Thread-6:2
Thread-7:3
Thread-7:4
Thread-6:5
Thread-6:6
Thread-6:7
Thread-6:8
Thread-6:9
Thread-5:10

那我們在看看通過extend Thread 的方式。它並沒有一個共同的Runnable物件來初始化3個Thread物件。每一個Thread都擁有自己一個獨立的Runnable物件。

當然不能實現資源的共享，因為現在每個Thread都有一個自己counter物件了。

那麼問題來了：難道用extends Thread的方式就不能實現共享嗎，答案是肯定可以實現：

方法有很多。我自己試著寫了一個：

package test;
public class TestThread {

	public static void main(String args[]) throws Exception {
		  ExtendsThread tc1 = new ExtendsThread();
		  tc1.start();
		  ExtendsThread tc2 = new ExtendsThread();
		  tc2.start();
		  ExtendsThread tc3 = new ExtendsThread();
		  tc3.start();
		}
}

class ExtendsThread extends Thread {
		public void run() {
			while(Resource.getCounter()<10){
				Resource.count();
			}
		}

}

package test;

public class Resource {
	private static int counter = 0;
	public static int getCounter(){
		return counter;
	}
	public static synchronized void count(){
		if(counter<10){
			counter++;
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+":"+counter);
		}
	}
} 

執行結果如下：

Thread-5:1
Thread-5:2
Thread-6:3
Thread-5:4
Thread-7:5
Thread-6:6
Thread-7:7
Thread-6:8
Thread-7:9
Thread-6:10

可以看到 在這段程式碼中 我counter設定成了static，相應的用了class級別的鎖。

不過相比implement runnable的方式還是麻煩了很多。

所以從上面兩個比較我們可以得出

實現Runnable介面相比繼承Thread類有如下好處：

　　->避免單點繼承的侷限，一個類可以繼承多個介面。

　　->適合於資源的共享