遊戲陪玩原始碼的輪詢鎖，使用時遇到的問題與解決方案

當我們遇到死鎖之後，除了可以手動重啟遊戲陪玩原始碼解決之外，還可以考慮是使用順序鎖和輪詢鎖，然而，遊戲陪玩原始碼的輪詢鎖在使用的過程中，如果使用不當會帶來新的嚴重問題，所以本篇我們就來了解一下這些問題，以及相應的解決方案。

問題演示

當遊戲陪玩原始碼沒有使用輪詢鎖之前，可能會出現這樣的問題：

import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class DeadLockByReentrantLock {
    public static void main(String[] args) {
        Lock lockA = new ReentrantLock(); // 建立鎖 A
        Lock lockB = new ReentrantLock(); // 建立鎖 B
        // 建立執行緒 1
        Thread t1 = new Thread(new Runnable() {
            @Override            public void run() {
                lockA.lock(); // 加鎖
                System.out.println("執行緒 1:獲取到鎖 A!");
                try {
                    Thread.sleep(1000);
                    System.out.println("執行緒 1:等待獲取 B...");
                    lockB.lock(); // 加鎖
                    try {
                        System.out.println("執行緒 1:獲取到鎖 B!");
                    } finally {
                        lockA.unlock(); // 釋放鎖
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockA.unlock(); // 釋放鎖
                }
            }
        });
        t1.start(); // 執行執行緒
        // 建立執行緒 2
        Thread t2 = new Thread(new Runnable() {
            @Override            public void run() {
                lockB.lock(); // 加鎖
                System.out.println("執行緒 2:獲取到鎖 B!");
                try {
                    Thread.sleep(1000);
                    System.out.println("執行緒 2:等待獲取 A...");
                    lockA.lock(); // 加鎖
                    try {
                        System.out.println("執行緒 2:獲取到鎖 A!");
                    } finally {
                        lockA.unlock(); // 釋放鎖
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockB.unlock(); // 釋放鎖
                }
            }
        });
        t2.start(); // 執行執行緒
    }}

以上程式碼的執行結果如下：

從上述結果可以看出，此時遊戲陪玩原始碼中出現了執行緒相互等待，並嘗試獲取對方（鎖）資源的情況，這就是典型的死鎖問題了。

簡易版輪詢鎖

當遊戲陪玩原始碼出現死鎖問題之後，我們就可以使用輪詢鎖來解決它了，它的實現思路是通過輪詢的方式來獲取多個鎖，如果中途有任意一個鎖獲取失敗，則執行回退操作，釋放當前執行緒擁有的所有鎖，等待下一次重新執行，這樣就可以避免多個執行緒同時擁有並霸佔鎖資源了，從而直接解決了遊戲陪玩原始碼中死鎖的問題，簡易版的輪詢鎖實現如下：

import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class SolveDeadLockExample2 {
    public static void main(String[] args) {
        Lock lockA = new ReentrantLock(); // 建立鎖 A
        Lock lockB = new ReentrantLock(); // 建立鎖 B
        // 建立執行緒 1(使用輪詢鎖)
        Thread t1 = new Thread(new Runnable() {
            @Override            public void run() {
                // 呼叫輪詢鎖
                pollingLock(lockA, lockB);
            }
        });
        t1.start(); // 執行執行緒
        // 建立執行緒 2
        Thread t2 = new Thread(new Runnable() {
            @Override            public void run() {
                lockB.lock(); // 加鎖
                System.out.println("執行緒 2:獲取到鎖 B!");
                try {
                    Thread.sleep(1000);
                    System.out.println("執行緒 2:等待獲取 A...");
                    lockA.lock(); // 加鎖
                    try {
                        System.out.println("執行緒 2:獲取到鎖 A!");
                    } finally {
                        lockA.unlock(); // 釋放鎖
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockB.unlock(); // 釋放鎖
                }
            }
        });
        t2.start(); // 執行執行緒
    }
    /**
     * 輪詢鎖
     */
    private static void pollingLock(Lock lockA, Lock lockB) {
        // 輪詢鎖
        while (true) {
            if (lockA.tryLock()) { // 嘗試獲取鎖
                System.out.println("執行緒 1:獲取到鎖 A!");
                try {
                    Thread.sleep(1000);
                    System.out.println("執行緒 1:等待獲取 B...");
                    if (lockB.tryLock()) { // 嘗試獲取鎖
                        try {
                            System.out.println("執行緒 1:獲取到鎖 B!");
                        } finally {
                            lockB.unlock(); // 釋放鎖
                            System.out.println("執行緒 1:釋放鎖 B.");
                            break;
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockA.unlock(); // 釋放鎖
                    System.out.println("執行緒 1:釋放鎖 A.");
                }
            }
            // 等待一秒再繼續執行
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }}

以上程式碼的執行結果如下：

從上述結果可以看出，當遊戲陪玩原始碼中使用輪詢鎖之後就不會出現死鎖的問題了，但以上輪詢鎖也並不是完美無缺的，下面我們來看看這個輪詢鎖會有什麼樣的問題？

問題1：死迴圈

以上簡易版的輪詢鎖，如果遇到遊戲陪玩原始碼中有一個執行緒一直霸佔或者長時間霸佔鎖資源的情況，就會導致這個輪詢鎖進入死迴圈的狀態，它會嘗試一直獲取鎖資源，這樣就會造成新的問題，帶來不必要的效能開銷，具體示例如下。

反例

import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class SolveDeadLockExample {
    public static void main(String[] args) {
        Lock lockA = new ReentrantLock(); // 建立鎖 A
        Lock lockB = new ReentrantLock(); // 建立鎖 B
        // 建立執行緒 1(使用輪詢鎖)
        Thread t1 = new Thread(new Runnable() {
            @Override            public void run() {
                // 呼叫輪詢鎖
                pollingLock(lockA, lockB);
            }
        });
        t1.start(); // 執行執行緒
        // 建立執行緒 2
        Thread t2 = new Thread(new Runnable() {
            @Override            public void run() {
                lockB.lock(); // 加鎖
                System.out.println("執行緒 2:獲取到鎖 B!");
                try {
                    Thread.sleep(1000);
                    System.out.println("執行緒 2:等待獲取 A...");
                    lockA.lock(); // 加鎖
                    try {
                        System.out.println("執行緒 2:獲取到鎖 A!");
                    } finally {
                        lockA.unlock(); // 釋放鎖
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // 如果此處程式碼未執行，執行緒 2 一直未釋放鎖資源
                    // lockB.unlock(); 
                }
            }
        });
        t2.start(); // 執行執行緒
    }
    /**
     * 輪詢鎖
     */
    public static void pollingLock(Lock lockA, Lock lockB) {
        while (true) {
            if (lockA.tryLock()) { // 嘗試獲取鎖
                System.out.println("執行緒 1:獲取到鎖 A!");
                try {
                    Thread.sleep(1000);
                    System.out.println("執行緒 1:等待獲取 B...");
                    if (lockB.tryLock()) { // 嘗試獲取鎖
                        try {
                            System.out.println("執行緒 1:獲取到鎖 B!");
                        } finally {
                            lockB.unlock(); // 釋放鎖
                            System.out.println("執行緒 1:釋放鎖 B.");
                            break;
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockA.unlock(); // 釋放鎖
                    System.out.println("執行緒 1:釋放鎖 A.");
                }
            }
            // 等待一秒再繼續執行
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }}

以上程式碼的執行結果如下：

從上述結果可以看出，執行緒 1 輪詢鎖進入了死迴圈的狀態。

優化版

針對以上死迴圈的情況，我們可以改進的思路有以下兩種：

1、在遊戲陪玩原始碼中新增最大次數限制：如果經過了 n 次嘗試獲取鎖之後，還未獲取到鎖，則認為獲取鎖失敗，執行失敗策略之後終止輪詢（失敗策略可以是記錄日誌或其他操作）；
2、在遊戲陪玩原始碼中新增最大時長限制：如果經過了 n 秒嘗試獲取鎖之後，還未獲取到鎖，則認為獲取鎖失敗，執行失敗策略之後終止輪詢。
以上策略任選其一就可以解決死迴圈的問題，出於實現成本的考慮，我們可以採用輪詢最大次數的方式來改進輪詢鎖，具體實現程式碼如下：

import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class SolveDeadLockExample {
    public static void main(String[] args) {
        Lock lockA = new ReentrantLock(); // 建立鎖 A
        Lock lockB = new ReentrantLock(); // 建立鎖 B
        // 建立執行緒 1(使用輪詢鎖)
        Thread t1 = new Thread(new Runnable() {
            @Override            public void run() {
                // 呼叫輪詢鎖
                pollingLock(lockA, lockB, 3);
            }
        });
        t1.start(); // 執行執行緒
        // 建立執行緒 2
        Thread t2 = new Thread(new Runnable() {
            @Override            public void run() {
                lockB.lock(); // 加鎖
                System.out.println("執行緒 2:獲取到鎖 B!");
                try {
                    Thread.sleep(1000);
                    System.out.println("執行緒 2:等待獲取 A...");
                    lockA.lock(); // 加鎖
                    try {
                        System.out.println("執行緒 2:獲取到鎖 A!");
                    } finally {
                        lockA.unlock(); // 釋放鎖
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // 執行緒 2 忘記釋放鎖資源
                    // lockB.unlock(); // 釋放鎖
                }
            }
        });
        t2.start(); // 執行執行緒
    }
    /**
     * 輪詢鎖
     *
     * maxCount：最大輪詢次數
     */
    public static void pollingLock(Lock lockA, Lock lockB, int maxCount) {
        // 輪詢次數計數器
        int count = 0;
        while (true) {
            if (lockA.tryLock()) { // 嘗試獲取鎖
                System.out.println("執行緒 1:獲取到鎖 A!");
                try {
                    Thread.sleep(1000);
                    System.out.println("執行緒 1:等待獲取 B...");
                    if (lockB.tryLock()) { // 嘗試獲取鎖
                        try {
                            System.out.println("執行緒 1:獲取到鎖 B!");
                        } finally {
                            lockB.unlock(); // 釋放鎖
                            System.out.println("執行緒 1:釋放鎖 B.");
                            break;
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockA.unlock(); // 釋放鎖
                    System.out.println("執行緒 1:釋放鎖 A.");
                }
            }
            // 判斷是否已經超過最大次數限制
            if (count++ > maxCount) {
                // 終止迴圈
                System.out.println("輪詢鎖獲取失敗,記錄日誌或執行其他失敗策略");
                return;
            }
            // 等待一秒再繼續嘗試獲取鎖
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }}

以上程式碼的執行結果如下：

從以上結果可以看出，當我們改進之後，輪詢鎖就不會出現死迴圈的問題了，它會嘗試一定次數之後終止執行。

問題2：執行緒餓死

我們以上的輪詢鎖的輪詢等待時間是固定時間，如下程式碼所示：

// 等待 1s 再嘗試獲取（輪詢）鎖try {
    Thread.sleep(1000);} catch (InterruptedException e) {
    e.printStackTrace();}

這樣在特殊情況下會造成遊戲陪玩原始碼執行緒餓死的問題，也就是輪詢鎖一直獲取不到鎖的問題，比如以下示例。

反例

import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class SolveDeadLockExample {
    public static void main(String[] args) {
        Lock lockA = new ReentrantLock(); // 建立鎖 A
        Lock lockB = new ReentrantLock(); // 建立鎖 B
        // 建立執行緒 1(使用輪詢鎖)
        Thread t1 = new Thread(new Runnable() {
            @Override            public void run() {
                // 呼叫輪詢鎖
                pollingLock(lockA, lockB, 3);
            }
        });
        t1.start(); // 執行執行緒
        // 建立執行緒 2
        Thread t2 = new Thread(new Runnable() {
            @Override            public void run() {
                while (true) {
                    lockB.lock(); // 加鎖
                    System.out.println("執行緒 2:獲取到鎖 B!");
                    try {
                        System.out.println("執行緒 2:等待獲取 A...");
                        lockA.lock(); // 加鎖
                        try {
                            System.out.println("執行緒 2:獲取到鎖 A!");
                        } finally {
                            lockA.unlock(); // 釋放鎖
                        }
                    } finally {
                        lockB.unlock(); // 釋放鎖
                    }
                    // 等待一秒之後繼續執行
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        t2.start(); // 執行執行緒
    }
    /**
     * 輪詢鎖
     */
    public static void pollingLock(Lock lockA, Lock lockB, int maxCount) {
        // 迴圈次數計數器
        int count = 0;
        while (true) {
            if (lockA.tryLock()) { // 嘗試獲取鎖
                System.out.println("執行緒 1:獲取到鎖 A!");
                try {
                    Thread.sleep(100); // 等待 0.1s(獲取鎖需要的時間)
                    System.out.println("執行緒 1:等待獲取 B...");
                    if (lockB.tryLock()) { // 嘗試獲取鎖
                        try {
                            System.out.println("執行緒 1:獲取到鎖 B!");
                        } finally {
                            lockB.unlock(); // 釋放鎖
                            System.out.println("執行緒 1:釋放鎖 B.");
                            break;
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockA.unlock(); // 釋放鎖
                    System.out.println("執行緒 1:釋放鎖 A.");
                }
            }
            // 判斷是否已經超過最大次數限制
            if (count++ > maxCount) {
                // 終止迴圈
                System.out.println("輪詢鎖獲取失敗,記錄日誌或執行其他失敗策略");
                return;
            }
            // 等待一秒再繼續嘗試獲取鎖
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }}

以上程式碼的執行結果如下：

從上述結果可以看出，執行緒 1（輪詢鎖）一直未成功獲取到鎖，造成這種結果的原因是：執行緒 1 每次輪詢的等待時間為固定的 1s，而執行緒 2 也是相同的頻率，每 1s 獲取一次鎖，這樣就會導致執行緒 2 會一直先成功獲取到鎖，而執行緒 1 則會一直處於“餓死”的情況，執行流程如下圖所示：

優化版

接下來，我們可以將遊戲陪玩原始碼中輪詢鎖的固定等待時間，改進為固定時間 + 隨機時間的方式，這樣就可以避免因為獲取鎖的頻率一致，而造成輪詢鎖“餓死”的問題了，具體實現程式碼如下：

import java.util.Random;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class SolveDeadLockExample {
    private static Random rdm = new Random();
    public static void main(String[] args) {
        Lock lockA = new ReentrantLock(); // 建立鎖 A
        Lock lockB = new ReentrantLock(); // 建立鎖 B
        // 建立執行緒 1(使用輪詢鎖)
        Thread t1 = new Thread(new Runnable() {
            @Override            public void run() {
                // 呼叫輪詢鎖
                pollingLock(lockA, lockB, 3);
            }
        });
        t1.start(); // 執行執行緒
        // 建立執行緒 2
        Thread t2 = new Thread(new Runnable() {
            @Override            public void run() {
                while (true) {
                    lockB.lock(); // 加鎖
                    System.out.println("執行緒 2:獲取到鎖 B!");
                    try {
                        System.out.println("執行緒 2:等待獲取 A...");
                        lockA.lock(); // 加鎖
                        try {
                            System.out.println("執行緒 2:獲取到鎖 A!");
                        } finally {
                            lockA.unlock(); // 釋放鎖
                        }
                    } finally {
                        lockB.unlock(); // 釋放鎖
                    }
                    // 等待一秒之後繼續執行
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        t2.start(); // 執行執行緒
    }
    /**
     * 輪詢鎖
     */
    public static void pollingLock(Lock lockA, Lock lockB, int maxCount) {
        // 迴圈次數計數器
        int count = 0;
        while (true) {
            if (lockA.tryLock()) { // 嘗試獲取鎖
                System.out.println("執行緒 1:獲取到鎖 A!");
                try {
                    Thread.sleep(100); // 等待 0.1s(獲取鎖需要的時間)
                    System.out.println("執行緒 1:等待獲取 B...");
                    if (lockB.tryLock()) { // 嘗試獲取鎖
                        try {
                            System.out.println("執行緒 1:獲取到鎖 B!");
                        } finally {
                            lockB.unlock(); // 釋放鎖
                            System.out.println("執行緒 1:釋放鎖 B.");
                            break;
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lockA.unlock(); // 釋放鎖
                    System.out.println("執行緒 1:釋放鎖 A.");
                }
            }
            // 判斷是否已經超過最大次數限制
            if (count++ > maxCount) {
                // 終止迴圈
                System.out.println("輪詢鎖獲取失敗,記錄日誌或執行其他失敗策略");
                return;
            }
            // 等待一定時間(固定時間 + 隨機時間)之後再繼續嘗試獲取鎖
            try {
                Thread.sleep(300 + rdm.nextInt(8) * 100); // 固定時間 + 隨機時間
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }}

以上程式碼的執行結果如下：

從上述結果可以看出，執行緒 1（輪詢鎖）加入隨機等待時間之後就不會出現執行緒餓死的問題了。

總結

本文我們介紹了遊戲陪玩原始碼中輪詢鎖的用途，用於解決死鎖問題，但簡易版的輪詢鎖在某些情況下會造成死迴圈和執行緒餓死的問題，因此我們對輪詢鎖進行了優化，給輪詢鎖加入了最大輪詢次數，以及隨機輪詢等待時間，這樣就可以解決因為引入輪詢鎖而造成的新問題了，這樣就可以愉快的使用它來解決遊戲陪玩原始碼中死鎖的問題了。