Java 多線程（二）—— 線程的同步

 上文創建多線程買票的例子中注釋會出現錯票、重票的問題，本文來講講如何解決此問題。本文例子：利用多線程模擬 3 個窗口賣票

實現Runnable接口

public class TestThread2 {
    public static void main(String [] args){
        Window window=new Window();
        Thread thread1=new Thread(window,"窗口一");
        Thread thread2=new Thread(window,"窗口二");
        Thread thread3=new Thread(window,"窗口三");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

class Window implements  Runnable{
    int ticket=50;
    @Override
    public void run(){
        while (true){
            if(ticket > 0){
                try {
                    Thread.currentThread().sleep(100);//模擬賣票需要一定的時間
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"售票，票號為："+ticket--);
            }else {
                break;
            }
        }
    }
}

運行結果：

窗口二售票，票號為：13
窗口三售票，票號為：12
窗口一售票，票號為：11
窗口二售票，票號為：10
窗口一售票，票號為：10
窗口三售票，票號為：10
窗口三售票，票號為：9
窗口一售票，票號為：8
窗口二售票，票號為：7
窗口三售票，票號為：6
窗口一售票，票號為：5
窗口二售票，票號為：4
窗口三售票，票號為：3
窗口一售票，票號為：2
窗口二售票，票號為：1
窗口三售票，票號為：0
窗口一售票，票號為：-1

 

結果分析：這里出現了票數為0和負數還有重票的情況，這在現實生活中肯定是不存在的，那么為什么會出現這樣的情況呢？

　　當票號為10時：A線程、B線程、C線程同時進入到if(ticket > 0)的代碼塊中，A線程已經執行了打印輸出語句，但是還沒有做ticket--操作；
　　這時B線程就開始執行了打印操作，那么就會出現兩個線程打印票數一樣，即賣的是同一張票
　　當票號為1時：A線程、B線程，C線程同時進入到if(ticket > 0)的代碼塊中，A線程執行了打印語句，並且已經做完了ticket--操作，則此時ticket=0；
　　B線程再打印時就出現了0的情況，同理C線程打印就會出現-1的情況。

解決辦法：即我們不能同時讓超過兩個以上的線程進入到 if(ticket > 0)的代碼塊中，不然就會出現上述的錯誤。必須讓一個線程操作共享數據完畢以后，其他線程才有機會參與共享數據的操作。我們可以通過以下兩個辦法來解決：

　　1、使用 同步代碼塊

　　2、使用 同步方法

使用 同步代碼塊

synchronized(同步監視器){
      //需要被同步的代碼塊（即為操作共享數據的代碼）
}

　　同步監視器：由任意一個類的對象來充當，哪個線程獲取此監視器，誰就執行大括號里被同步的代碼。俗稱：鎖

　　要求：1、所有的線程必須公用同一把鎖！不能相對於線程是變化的對象；

　　　　    2、並且只需鎖住操作共享數據的代碼，鎖多了或少了都不行；

 

實例：

1、實現的方式

public class TestWindow {
    public static void main(String [] args){
        Window1 window=new Window1();
        Thread thread1=new Thread(window,"窗口一");
        Thread thread2=new Thread(window,"窗口二");
        Thread thread3=new Thread(window,"窗口三");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

class Window1 implements  Runnable{
    int ticket=100;//共享數據
    @Override
    public void  run(){
        while (true){
            synchronized (this){//this表示當前對象，此時表示創建的 window
                if(ticket > 0){
                    try {
                        //模擬賣票需要一定的時間
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"售票，票號為："+ticket--);
                }
            }
        }
    }
}

注意：在實現的方式中，考慮同步的話，可以使用this充當鎖，但在繼承的方式中，會創建多個對象，慎用this

2、繼承的方式

public class TestWindow1 {
    public static void main(String [] args){
        Window2 window1=new Window2();
        Window2 window2=new Window2();
        window1.start();
        window2.start();
    }
}


class Window2 extends Thread{
    static int ticket=100;//共享數據；注意聲明為 static,表示幾個窗口共享
    static Object object=new Object();//用static 可以表示唯一
    @Override
    public void  run(){
        while (true){
            //synchronized (this){//this表示當前對象，此時表示創建的 window1和window2
            synchronized (object){//鎖必須是唯一，不能每個線程都使用自己的一把鎖
                if(ticket > 0){
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"售票，票號為："+ticket--);
                }
            }
        }
    }
}

注意：1、繼承的方式會創建多個實例，所以共享資源需要用static來修飾，表示共享

　　    2、繼承的方式會創建多個實例，所以 this 表示不同的實例對象，這里表示widow1和window2,所以不能使用this當鎖，此時可以定義一個 static 修飾的對象當鎖

 

使用 同步方法

語法：即用  synchronized  關鍵字修飾方法

將操作共享數據的方法聲明為synchronized。即此方法為同步方法，能夠保證當其中一個線程執行此方法時，其他線程再外等待直至此線程執行完此方法。
注意：同步方法的鎖：this

實例：

1、實現的方式

public class TestWindow2 {
    public static void main(String [] args){
        Window3 window=new Window3();
        Thread thread1=new Thread(window,"窗口一");
        Thread thread2=new Thread(window,"窗口二");
        Thread thread3=new Thread(window,"窗口三");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

class Window3 implements  Runnable{
    int ticket=100;//共享數據
    @Override
    public void  run(){
        while (true){
            show();
        }
    }

    public synchronized void show(){//this充當鎖，此時表示創建的 window；
        // 如果用繼承的方式，使用同步方法，這里表示創建的 window1和window2，繼承的方式不要使用同步方法
        if(ticket > 0){
            try {
                Thread.currentThread().sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"售票，票號為："+ticket--);
        }
    }
}

 

注意：1、synchronized 的鎖為this，這里表示創建的對象實例window；

　　   2、繼承的時候t this 表示創建的window1和window2，繼承的方式不要使用同步方法。