引言

現有一個需求如下：

有10000張火車票，每張票都有一個編號，同時有10個視窗對外售票，如何確保車票的正常售賣？

程式一：使用List

問題的解決辦法都是從我們最最熟悉的角度思考。程式一，我們使用一個普通的List作為方案。

閱讀以下程式碼，觀察執行結果：

public class TicketSell_01 {
    static List<String> tickets = new ArrayList<>();

    static {
        for (int i = 0; i < 10000; i++)
            tickets.add("票編號： " + i);
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                while (tickets.size() > 0) {
                    System.out.println("銷售了--" + tickets.remove(0));
                }
            }).start();
        }
    }
}
 

輸出結果如下，可以看到，編號0的車票被銷售了兩次。List不是同步容器，容器內的remove()等方法都無法做到原子性，因此會出現重複售票的問題，因此是不安全的：

程式二：使用Vector

以Vector代替List作為容器。區別是，Vector是同步容器，內部的方法都是同步的。但是下面的程式碼依然會存在問題。

雖然size()方法和remove()方法本身是原子性的，其他執行緒無法打斷，但是在判斷size和remove之間的部分依然會有執行緒交叉執行的可能，這樣，雖然可以解決重複銷售的問題，但是依然會導致：ArrayIndexOutOfBoundsException

public class TicketSell_02 {
    static Vector<String> tickets = new Vector<>();

    static {
        for (int i = 0; i < 10000; i++)
            tickets.add("票編號： " + i);
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                while (tickets.size() > 0) {
                    try {
                        TimeUnit.MILLISECONDS.sleep(5);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    System.out.println("銷售了--" + tickets.remove(0));
                }
            }).start();
        }
    }
}
 

執行結果：

程式三：同步

使用synchronized進行執行緒同步，可以有效解決邏輯問題，但是很明顯，這種方法的缺點就是效率低下。

public class TicketSell_03 {
    static List<String> tickets = new LinkedList<>();

    static {
        for (int i = 0; i < 10000; i++)
            tickets.add("票編號： " + i);
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                while (true) {
                    synchronized (tickets) {
                        if (tickets.size() == 0)
                            break;
                        System.out.println("銷售了票--" + tickets.remove(0));
                    }
                }
            }).start();
        }
    }
}
 

程式四：併發容器Queue

ConcurrentLinkedQueue是一個併發佇列。但凡併發容器，其內部的方法都保證是原子性的。下面的程式碼中poll()表示從佇列的頭部獲得一個數據，當返回值為null時，代表這個佇列已經沒有值了。因為佇列本身不允許存null值，否則會報空指標異常，因此當返回值為null時，一定表示佇列已空（size() == 0）。佇列的底層是使用一個叫做CompareAndSet（CAS）的技術實現的，不是加鎖的實現，因此在高併發的情況下依然可以擁有很高的效率。

public class TicketSell_04 {
    static Queue<String> tickets = new ConcurrentLinkedQueue<>();

    static {
        for (int i = 0; i < 10000; i++)
            tickets.add("票編號： " + i);
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                while (true) {
                    String s = tickets.poll();
                    if (s == null)
                        break;
                    else
                        System.out.println("銷售了--" + s);
                }
            }).start();
        }
    }
}