天天看點

Java的兩種多線程實作方式

一、建立多線程的兩種方式

Java中,有兩種方式可以建立多線程:

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

2 通過實作Runnable接口,執行個體化Thread類

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

程式1:

package z;

class MyThread extends Thread{    
    private int ticket = 10;  
    private String name;  
    public MyThread(String name){  
        this.name =name;  
    }  

    public void run(){  
        for(int i = 0; i < 500; i++){  
            if(this.ticket > 0){  
                System.out.println(this.name+"賣票---->"+(this.ticket--));  
            }  
        }  
    }  
} 

public class ThreadDemo  
    public static void main(String[] args) {  
        MyThread mt1= new MyThread("一号視窗");  
        MyThread mt2= new MyThread("二号視窗");  
        MyThread mt3= new MyThread("三号視窗");  
        mt1.start();  
        mt2.start();  
        mt3.start();  
    }  
}        

運作結果:

一号視窗賣票---->10
一号視窗賣票---->9
一号視窗賣票---->8
一号視窗賣票---->7
一号視窗賣票---->6
一号視窗賣票---->5
一号視窗賣票---->4
一号視窗賣票---->3
一号視窗賣票---->2
一号視窗賣票---->1
三号視窗賣票---->10
三号視窗賣票---->9
三号視窗賣票---->8
三号視窗賣票---->7
二号視窗賣票---->10
二号視窗賣票---->9
二号視窗賣票---->8
三号視窗賣票---->6
三号視窗賣票---->5
三号視窗賣票---->4
三号視窗賣票---->3
二号視窗賣票---->7
二号視窗賣票---->6
二号視窗賣票---->5
二号視窗賣票---->4
二号視窗賣票---->3
二号視窗賣票---->2
二号視窗賣票---->1
三号視窗賣票---->2
三号視窗賣票---->1      

程式2:

package z;

class MyThread1 implements Runnable{  
    private int ticket =10;  
    public void run(){  
        for(int i = 0; i<500; i++){ 
            if(this.ticket>0){
                    System.out.println(Thread.currentThread().getName() + "賣票---->" + (this.ticket--));  
            }  
        }  
    }  
} 

public class RunnableDemo  

    public static void main(String[] args) {  
        // 設計三個線程  
        MyThread1 mt = new MyThread1();  
        Thread t1 = new Thread(mt, "一号視窗");  
        Thread t2 = new Thread(mt, "二号視窗");  
        Thread t3 = new Thread(mt, "三号視窗");  
        t1.start();  
        t2.start();  
        t3.start();  
    }  
}        

運作結果:

三号視窗賣票---->10
三号視窗賣票---->7
三号視窗賣票---->6
三号視窗賣票---->5
三号視窗賣票---->4
三号視窗賣票---->3
一号視窗賣票---->8
二号視窗賣票---->9
一号視窗賣票---->1
三号視窗賣票---->2      

為什麼兩個程式的結果不同呢?

第1個程式,相當于拿出三件事即三個賣票10張的任務分别分給三個視窗,他們各做各的事各賣各的票各完成各的任務,因為MyThread繼承Thread類,是以在new MyThread的時候在建立三個對象的同時建立了三個線程。

第2個程式,相當于是拿出一個賣票10張得任務給三個人去共同完成,new MyThread相當于建立一個任務,然後執行個體化三個Thread,建立三個線程即安排三個視窗去執行。

用圖表示如下:

Java的兩種多線程實作方式

通過上面的分析,我們發現這兩種多線程有兩大差別:

(1) Thread方式是繼承;Runnable方式是實作接口。

(2) Thread方式是多個線程分别完成自己的任務,即資料獨立;Runnable方式是多個線程共同完成一個任務,即資料共享。

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

二、隐含的問題

在第二種方法中,由于3個Thread對象共同執行一個Runnable對象中的代碼,是以可能會造成線程的不安全,比如可能ticket會輸出-1(如果我們System.out….語句前加上線程休眠操作,該情況将很有可能出現)。

這種情況的出現是由于,一個線程在判斷ticket為1>0後,還沒有來得及減1,另一個線程已經将ticket減1,變為了0,那麼接下來之前的線程再将ticket減1,便得到了-1。

這就需要加入同步操作(即互斥鎖),確定同一時刻隻有一個線程在執行每次for循環中的操作。

而在第一種方法中,并不需要加入同步操作,因為每個線程執行自己Thread對象中的代碼,不存在多個線程共同執行同一個方法的情況。

程式1:

package z;

class MyThread1 implements Runnable{  
    private int ticket = 10;  
    public void run(){  
        for(int i = 0; i<500; i++){ 
            if(this.ticket>0){
                try {
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + "賣票---->" + (this.ticket--));  
                }catch(Exception e) {
                    e.printStackTrace();
                }
            }  
        }  
    }  
} 

public class RunnableDemo  

    public static void main(String[] args) {  
        // 設計三個線程  
        MyThread1 mt = new MyThread1();  
        Thread t1 = new Thread(mt, "一号視窗");  
        Thread t2 = new Thread(mt, "二号視窗");  
        Thread t3 = new Thread(mt, "三号視窗");  
        t1.start();  
        t2.start();  
        t3.start();  
    }  
}        

運作結果:

一号視窗賣票---->10
二号視窗賣票---->10
三号視窗賣票---->9
一号視窗賣票---->8
三号視窗賣票---->7
二号視窗賣票---->8
一号視窗賣票---->6
三号視窗賣票---->4
二号視窗賣票---->5
三号視窗賣票---->3
二号視窗賣票---->2
一号視窗賣票---->3
二号視窗賣票---->1
三号視窗賣票---->-1
一号視窗賣票---->0      

程式2:

package z;

class MyThread1 implements Runnable{  
    private int ticket = 1000;  
    public void run(){  
        for(int i = 0; i<5000; i++){ 
            synchronized(this) {
                if(this.ticket>0){
                    System.out.println(Thread.currentThread().getName()+"賣票---->"+(this.ticket--));  
                }  
            }
        }  
    }  
}

public class RunnableDemo  

    public static void main(String[] args) {  
        // 設計三個線程  
        MyThread1 mt = new MyThread1();  
        Thread t1 = new Thread(mt, "一号視窗");  
        Thread t2 = new Thread(mt, "二号視窗");  
        Thread t3 = new Thread(mt, "三号視窗");  
        t1.start();  
        t2.start();  
        t3.start();  
    }  
}        

運作結果:

一号視窗賣票---->10
一号視窗賣票---->9
一号視窗賣票---->8
一号視窗賣票---->7
一号視窗賣票---->6
一号視窗賣票---->5
一号視窗賣票---->4
一号視窗賣票---->3
一号視窗賣票---->2
一号視窗賣票---->1      

注意,這裡的10張票都是一号視窗賣出的。這是因為用了synchronized并且票數太少了,在t1對this對象鎖定的時間内,10張票就已經被賣完了。輪到t2或t3鎖定this對象時,已經無票可賣了。如果票數多一點,比如有幾萬張,就可以看到三個視窗都參與了賣票。