以前以為這兩種方法實現執行緒的效果是一樣的，只會寫的方法不一樣罷了，可是今天通過一個多執行緒程式發現了他們的區別，首先我們先來對比一下下面的兩個例子：
首先我們先來看一個繼承thread實現的多執行緒的賣票問題：

package threadtest;

class mythread extends Thread {
    private int tricket = 10;
    public mythread(String name) {
        // TODO Auto-generated constructor stub
        super(name);
    }

    public
 
 void run() {
        // TODO Auto-generated method stub
        while (true) {
            if (tricket > 0) {
                try {
                    Thread.sleep(100);
                } catch (Exception e) {
                    // TODO: handle exception
                    e.printStackTrace();
                }
                System.out.println(currentThread().getName() + " "
 
 + tricket--
                        + "號票");
            }
        }
    }
}

class myrunnable implements Runnable {
    private int tricket = 10;
    public void run() {
        // TODO Auto-generated method stub
        while (true) {
            if (tricket > 0) {
                try {
                    Thread.sleep(100
 
);
                } catch (Exception e) {
                    // TODO: handle exception
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " " + tricket--
                        + "號票");
            }           
        }
    }
}

public class test {
    public static void main(String[] args) {
        mythread thread1=new mythread("1號售票點");
        mythread thread2=new mythread("2號售票點");
        thread1.start();
        thread2.start();
    }

}

程式碼執行的結果：

然後我們用runnable介面實現以下

package threadtest;

class mythread extends Thread {
    private int tricket = 10;
    public mythread(String name) {
        // TODO Auto-generated constructor stub
        super(name);
    }

    public void run() {
        // TODO Auto-generated method stub
        while (true) {
            if (tricket > 0) {
                try {
                    Thread.sleep(100);
                } catch (Exception e) {
                    // TODO: handle exception
                    e.printStackTrace();
                }
                System.out.println(currentThread().getName() + " " + tricket--
                        + "號票");
            }
        }
    }
}

class myrunnable implements Runnable {
    private int tricket = 10;
    public void run() {
        // TODO Auto-generated method stub
        while (true) {
            if (tricket > 0) {
//              try {
//                  Thread.sleep(100);
//              } catch (Exception e) {
//                  // TODO: handle exception
//                  e.printStackTrace();
//              }
                System.out.println(Thread.currentThread().getName() + " " + tricket--
                        + "號票");
            }           
        }
    }
}

public class test {
    public static void main(String[] args) {
//      mythread thread1=new mythread("1號售票點");
//      mythread thread2=new mythread("2號售票點");
//      thread1.start();
//      thread2.start();
        myrunnable runnable=new myrunnable();
        Thread thread1=new Thread(runnable, "1號售票點");
        Thread thread2=new Thread(runnable, "2號售票點");
        thread1.start();
        thread2.start();
    }

}

執行結果是：

為什麼會出現這種結果吶。我們不妨做個比喻，其實剛的程式，
繼承Thread類的，我們相當於拿出三件事即三個賣票10張的任務分別分給三個視窗，他們各做各的事各賣各的票各完成各的任務，因為MyThread繼承Thread類，所以在new MyThread的時候在建立三個物件的同時建立了三個執行緒；
實現Runnable的， 相當於是拿出一個賣票10張得任務給三個人去共同完成，new MyThread相當於建立一個任務，然後例項化三個Thread，建立三個執行緒即安排三個視窗去執行。

用圖表示如下：

在我們剛接觸的時候可能會迷糊繼承Thread類和實現Runnable介面實現多執行緒，其實在接觸後我們會發現這完全是兩個不同的實現多執行緒，一個是多個執行緒分別完成自己的任務，一個是多個執行緒共同完成一個任務。

其實在實現一個任務用多個執行緒來做也可以用繼承Thread類來實現只是比較麻煩，一般我們用實現Runnable介面來實現，簡潔明瞭。

大多數情況下，如果只想重寫 run() 方法，而不重寫其他 Thread 方法，那麼應使用 Runnable 介面。這很重要，因為除非程式設計師打算修改或增強類的基本行為，否則不應為該類（Thread）建立子類。