1. 程式人生 > >Thread 和Runnable區別

Thread 和Runnable區別

tool 邏輯 method 自己的 當我 行為 接口實現 線程的創建 多線程

Java中線程的創建有兩種方式:

1. 通過繼承Thread類,重寫Thread的run()方法,將線程運行的邏輯放在其中

2. 通過實現Runnable接口,實例化Thread類

在實際應用中,我們經常用到多線程,如車站的售票系統,車站的各個售票口相當於各個線程。當我們做這個系統的時候可能會想到兩種方式來實現,繼承Thread類或實現Runnable接口,現在看一下這兩種方式實現的兩種結果。

Java代碼
  1. package com.threadtest;
  2. class MyThread extends Thread{
  3. private int ticket = 10;
  4. private String name;
  5. public MyThread(String name){
  6. this.name =name;
  7. }
  8. public void run(){
  9. for(int i =0;i<500;i++){
  10. if(this.ticket>0){
  11. System.out.println(this.name+"賣票---->"+(this.ticket--));
  12. }
  13. }
  14. }
  15. }
  16. public class ThreadDemo {
  17. public static void main(String[] args) {
  18. MyThread mt1= new MyThread("一號窗口");
  19. MyThread mt2= new MyThread("二號窗口");
  20. MyThread mt3= new MyThread("三號窗口");
  21. mt1.start();
  22. mt2.start();
  23. mt3.start();
  24. }
  25. }

運行結果如下:

Java代碼
  1. 一號窗口賣票---->10
  2. 一號窗口賣票---->9
  3. 二號窗口賣票---->10
  4. 一號窗口賣票---->8
  5. 一號窗口賣票---->7
  6. 一號窗口賣票---->6
  7. 三號窗口賣票---->10
  8. 一號窗口賣票---->5
  9. 一號窗口賣票---->4
  10. 一號窗口賣票---->3
  11. 一號窗口賣票---->2
  12. 一號窗口賣票---->1
  13. 二號窗口賣票---->9
  14. 二號窗口賣票---->8
  15. 三號窗口賣票---->9
  16. 三號窗口賣票---->8
  17. 三號窗口賣票---->7
  18. 三號窗口賣票---->6
  19. 三號窗口賣票---->5
  20. 三號窗口賣票---->4
  21. 三號窗口賣票---->3
  22. 三號窗口賣票---->2
  23. 三號窗口賣票---->1
  24. 二號窗口賣票---->7
  25. 二號窗口賣票---->6
  26. 二號窗口賣票---->5
  27. 二號窗口賣票---->4
  28. 二號窗口賣票---->3
  29. 二號窗口賣票---->2
  30. 二號窗口賣票---->1

通過實現Runnable接口的代碼如下:

Java代碼
  1. package com.threadtest;
  2. class MyThread1 implements Runnable{
  3. private int ticket =10;
  4. private String name;
  5. public void run(){
  6. for(int i =0;i<500;i++){
  7. if(this.ticket>0){
  8. System.out.println(Thread.currentThread().getName()+"賣票---->"+(this.ticket--));
  9. }
  10. }
  11. }
  12. }
  13. public class RunnableDemo {
  14. public static void main(String[] args) {
  15. // TODO Auto-generated method stub
  16. //設計三個線程
  17. MyThread1 mt = new MyThread1();
  18. Thread t1 = new Thread(mt,"一號窗口");
  19. Thread t2 = new Thread(mt,"二號窗口");
  20. Thread t3 = new Thread(mt,"三號窗口");
  21. // MyThread1 mt2 = new MyThread1();
  22. // MyThread1 mt3 = new MyThread1();
  23. t1.start();
  24. t2.start();
  25. t3.start();
  26. }
  27. }

運行結果如下:

Java代碼
  1. 一號窗口賣票---->10
  2. 三號窗口賣票---->9
  3. 三號窗口賣票---->7
  4. 三號窗口賣票---->5
  5. 三號窗口賣票---->4
  6. 三號窗口賣票---->3
  7. 三號窗口賣票---->2
  8. 三號窗口賣票---->1
  9. 一號窗口賣票---->8
  10. 二號窗口賣票---->6

為什麽會出現這種結果吶。我們不妨做個比喻,其實剛的程序,

繼承Thread類的,我們相當於拿出三件事即三個賣票10張的任務分別分給三個窗口,他們各做各的事各賣各的票各完成各的任務,因為MyThread繼承Thread類,所以在new MyThread的時候在創建三個對象的同時創建了三個線程;

實現Runnable的, 相當於是拿出一個賣票10張得任務給三個人去共同完成,new MyThread相當於創建一個任務,然後實例化三個Thread,創建三個線程即安排三個窗口去執行。





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

其實在實現一個任務用多個線程來做也可以用繼承Thread類來實現只是比較麻煩,一般我們用實現Runnable接口來實現,簡潔明了。

大多數情況下,如果只想重寫 run() 方法,而不重寫其他 Thread 方法,那麽應使用 Runnable 接口。這很重要,因為除非程序員打算修改或增強類的基本行為,否則不應為該類(Thread)創建子類。

Thread 和Runnable區別