欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

Java?輪詢鎖使用時(shí)遇到問(wèn)題解決方案

 更新時(shí)間：2022年05月11日 17:16:21   作者：??Java中文社群????  
這篇文章主要介紹了Java?輪詢鎖使用時(shí)遇到問(wèn)題解決方案，當(dāng)我們遇到死鎖之后，除了可以手動(dòng)重啟程序解決之外，還可以考慮使用順序鎖和輪詢鎖，但是過(guò)程也會(huì)遇到一些問(wèn)題，接下來(lái)我們一起進(jìn)入下面文章了解解決方案，需要的小伙伴可以參考一下

前言：

當(dāng)我們遇到死鎖之后，除了可以手動(dòng)重啟程序解決之外，還可以考慮使用順序鎖和輪詢鎖，這部分的內(nèi)容可以參考上一篇文章Java 死鎖解決方案順序鎖和輪詢鎖，這里就不再贅述了。然而，輪詢鎖在使用的過(guò)程中，如果使用不當(dāng)會(huì)帶來(lái)新的嚴(yán)重問(wèn)題，所以本篇我們就來(lái)了解一下這些問(wèn)題，以及相應(yīng)的解決方案。

問(wèn)題演示

當(dāng)我們沒(méi)有使用輪詢鎖之前，可能會(huì)出現(xiàn)這樣的問(wèn)題：

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(); // 創(chuàng)建鎖 A
        Lock lockB = new ReentrantLock(); // 創(chuàng)建鎖 B

        // 創(chuàng)建線程 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(); // 運(yùn)行線程

        // 創(chuàng)建線程 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(); // 運(yùn)行線程
    }
}

以上代碼的執(zhí)行結(jié)果如下：

從上述結(jié)果可以看出，此時(shí)程序中出現(xiàn)了線程相互等待，并嘗試獲取對(duì)方（鎖）資源的情況，這就是典型的死鎖問(wèn)題了。

簡(jiǎn)易版輪詢鎖

當(dāng)出現(xiàn)死鎖問(wèn)題之后，我們就可以使用輪詢鎖來(lái)解決它了，它的實(shí)現(xiàn)思路是通過(guò)輪詢的方式來(lái)獲取多個(gè)鎖，如果中途有任意一個(gè)鎖獲取失敗，則執(zhí)行回退操作，釋放當(dāng)前線程擁有的所有鎖，等待下一次重新執(zhí)行，這樣就可以避免多個(gè)線程同時(shí)擁有并霸占鎖資源了，從而直接解決了死鎖的問(wèn)題，簡(jiǎn)易版的輪詢鎖實(shí)現(xiàn)如下：

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(); // 創(chuàng)建鎖 A
        Lock lockB = new ReentrantLock(); // 創(chuàng)建鎖 B

        // 創(chuàng)建線程 1(使用輪詢鎖)
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 調(diào)用輪詢鎖
                pollingLock(lockA, lockB);
            }
        });
        t1.start(); // 運(yùn)行線程

        // 創(chuàng)建線程 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(); // 運(yùn)行線程
    }

    /**
     * 輪詢鎖
     */
    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.");
                }
            }
            // 等待一秒再繼續(xù)執(zhí)行
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

以上代碼的執(zhí)行結(jié)果如下：

從上述結(jié)果可以看出，當(dāng)我們?cè)诔绦蛑惺褂幂喸冩i之后就不會(huì)出現(xiàn)死鎖的問(wèn)題了，但以上輪詢鎖也并不是完美無(wú)缺的，下面我們來(lái)看看這個(gè)輪詢鎖會(huì)有什么樣的問(wèn)題？

問(wèn)題1：死循環(huán)

以上簡(jiǎn)易版的輪詢鎖，如果遇到有一個(gè)線程一直霸占或者長(zhǎng)時(shí)間霸占鎖資源的情況，就會(huì)導(dǎo)致這個(gè)輪詢鎖進(jìn)入死循環(huán)的狀態(tài)，它會(huì)嘗試一直獲取鎖資源，這樣就會(huì)造成新的問(wèn)題，帶來(lái)不必要的性能開(kāi)銷(xiāo)，具體示例如下。

反例

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(); // 創(chuàng)建鎖 A
        Lock lockB = new ReentrantLock(); // 創(chuàng)建鎖 B

        // 創(chuàng)建線程 1(使用輪詢鎖)
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 調(diào)用輪詢鎖
                pollingLock(lockA, lockB);
            }
        });
        t1.start(); // 運(yùn)行線程

        // 創(chuàng)建線程 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 {
                    // 如果此處代碼未執(zhí)行，線程 2 一直未釋放鎖資源
                    // lockB.unlock(); 
                }
            }
        });
        t2.start(); // 運(yùn)行線程
    }

    /**
     * 輪詢鎖
     */
    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.");
                }
            }
            // 等待一秒再繼續(xù)執(zhí)行
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

以上代碼的執(zhí)行結(jié)果如下： 

從上述結(jié)果可以看出，線程 1 輪詢鎖進(jìn)入了死循環(huán)的狀態(tài)。

優(yōu)化版

針對(duì)以上死循環(huán)的情況，我們可以改進(jìn)的思路有以下兩種：

  • 添加最大次數(shù)限制：如果經(jīng)過(guò)了 n 次嘗試獲取鎖之后，還未獲取到鎖，則認(rèn)為獲取鎖失敗，執(zhí)行失敗策略之后終止輪詢（失敗策略可以是記錄日志或其他操作）；
  • 添加最大時(shí)長(zhǎng)限制：如果經(jīng)過(guò)了 n 秒嘗試獲取鎖之后，還未獲取到鎖，則認(rèn)為獲取鎖失敗，執(zhí)行失敗策略之后終止輪詢。

以上策略任選其一就可以解決死循環(huán)的問(wèn)題，出于實(shí)現(xiàn)成本的考慮，我們可以采用輪詢最大次數(shù)的方式來(lái)改進(jìn)輪詢鎖，

具體實(shí)現(xià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(); // 創(chuàng)建鎖 A
        Lock lockB = new ReentrantLock(); // 創(chuàng)建鎖 B

        // 創(chuàng)建線程 1(使用輪詢鎖)
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 調(diào)用輪詢鎖
                pollingLock(lockA, lockB, 3);
            }
        });
        t1.start(); // 運(yùn)行線程

        // 創(chuàng)建線程 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(); // 運(yùn)行線程
    }

    /**
     * 輪詢鎖
     *
     * maxCount：最大輪詢次數(shù)
     */
    public static void pollingLock(Lock lockA, Lock lockB, int maxCount) {
        // 輪詢次數(shù)計(jì)數(shù)器
        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.");
                }
            }

            // 判斷是否已經(jīng)超過(guò)最大次數(shù)限制
            if (count++ > maxCount) {
                // 終止循環(huán)
                System.out.println("輪詢鎖獲取失敗,記錄日志或執(zhí)行其他失敗策略");
                return;
            }

            // 等待一秒再繼續(xù)嘗試獲取鎖
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

以上代碼的執(zhí)行結(jié)果如下：

從以上結(jié)果可以看出，當(dāng)我們改進(jìn)之后，輪詢鎖就不會(huì)出現(xiàn)死循環(huán)的問(wèn)題了，它會(huì)嘗試一定次數(shù)之后終止執(zhí)行。

問(wèn)題2：線程餓死

我們以上的輪詢鎖的輪詢等待時(shí)間是固定時(shí)間，如下代碼所示：

// 等待 1s 再嘗試獲?。ㄝ喸儯╂i
try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    e.printStackTrace();
}

這樣在特殊情況下會(huì)造成線程餓死的問(wèn)題，也就是輪詢鎖一直獲取不到鎖的問(wè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(); // 創(chuàng)建鎖 A
        Lock lockB = new ReentrantLock(); // 創(chuàng)建鎖 B

        // 創(chuàng)建線程 1(使用輪詢鎖)
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 調(diào)用輪詢鎖
                pollingLock(lockA, lockB, 3);
            }
        });
        t1.start(); // 運(yùn)行線程

        // 創(chuàng)建線程 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(); // 釋放鎖
                    }
                    // 等待一秒之后繼續(xù)執(zhí)行
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        t2.start(); // 運(yùn)行線程
    }

    /**
     * 輪詢鎖
     */
    public static void pollingLock(Lock lockA, Lock lockB, int maxCount) {
        // 循環(huán)次數(shù)計(jì)數(shù)器
        int count = 0;
        while (true) {
            if (lockA.tryLock()) { // 嘗試獲取鎖
                System.out.println("線程 1:獲取到鎖 A!");
                try {
                    Thread.sleep(100); // 等待 0.1s(獲取鎖需要的時(shí)間)
                    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.");
                }
            }

            // 判斷是否已經(jīng)超過(guò)最大次數(shù)限制
            if (count++ > maxCount) {
                // 終止循環(huán)
                System.out.println("輪詢鎖獲取失敗,記錄日志或執(zhí)行其他失敗策略");
                return;
            }

            // 等待一秒再繼續(xù)嘗試獲取鎖
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

以上代碼的執(zhí)行結(jié)果如下：

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

優(yōu)化版

接下來(lái)，我們可以將輪詢鎖的固定等待時(shí)間，改進(jìn)為固定時(shí)間 + 隨機(jī)時(shí)間的方式，這樣就可以避免因?yàn)楂@取鎖的頻率一致，而造成輪詢鎖“餓死”的問(wèn)題了，具體實(shí)現(xiàn)代碼如下：

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(); // 創(chuàng)建鎖 A
        Lock lockB = new ReentrantLock(); // 創(chuàng)建鎖 B

        // 創(chuàng)建線程 1(使用輪詢鎖)
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 調(diào)用輪詢鎖
                pollingLock(lockA, lockB, 3);
            }
        });
        t1.start(); // 運(yùn)行線程

        // 創(chuàng)建線程 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(); // 釋放鎖
                    }
                    // 等待一秒之后繼續(xù)執(zhí)行
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        t2.start(); // 運(yùn)行線程
    }

    /**
     * 輪詢鎖
     */
    public static void pollingLock(Lock lockA, Lock lockB, int maxCount) {
        // 循環(huán)次數(shù)計(jì)數(shù)器
        int count = 0;
        while (true) {
            if (lockA.tryLock()) { // 嘗試獲取鎖
                System.out.println("線程 1:獲取到鎖 A!");
                try {
                    Thread.sleep(100); // 等待 0.1s(獲取鎖需要的時(shí)間)
                    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.");
                }
            }

            // 判斷是否已經(jīng)超過(guò)最大次數(shù)限制
            if (count++ > maxCount) {
                // 終止循環(huán)
                System.out.println("輪詢鎖獲取失敗,記錄日志或執(zhí)行其他失敗策略");
                return;
            }

            // 等待一定時(shí)間(固定時(shí)間 + 隨機(jī)時(shí)間)之后再繼續(xù)嘗試獲取鎖
            try {
                Thread.sleep(300 + rdm.nextInt(8) * 100); // 固定時(shí)間 + 隨機(jī)時(shí)間
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

以上代碼的執(zhí)行結(jié)果如下：

從上述結(jié)果可以看出，線程 1（輪詢鎖）加入隨機(jī)等待時(shí)間之后就不會(huì)出現(xiàn)線程餓死的問(wèn)題了。

總結(jié)

本文我們介紹了輪詢鎖的用途，用于解決死鎖問(wèn)題，但簡(jiǎn)易版的輪詢鎖在某些情況下會(huì)造成死循環(huán)和線程餓死的問(wèn)題，因此我們對(duì)輪詢鎖進(jìn)行了優(yōu)化，給輪詢鎖加入了最大輪詢次數(shù)，以及隨機(jī)輪詢等待時(shí)間，這樣就可以解決因?yàn)橐胼喸冩i而造成的新問(wèn)題了，這樣就可以愉快的使用它來(lái)解決死鎖的問(wèn)題了。

到此這篇關(guān)于Java 輪詢鎖使用時(shí)遇到問(wèn)題解決方案的文章就介紹到這了,更多相關(guān)Java 輪詢鎖內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

相關(guān)文章

  • Java中位運(yùn)算(移位、位與、或、異或、非） 的簡(jiǎn)單實(shí)例

    Java中位運(yùn)算(移位、位與、或、異或、非） 的簡(jiǎn)單實(shí)例

    Java中位運(yùn)算(移位、位與、或、異或、非） 的簡(jiǎn)單實(shí)例，需要的朋友可以參考一下
    2013-02-02
  • SpringCloud Feign傳遞HttpServletRequest對(duì)象流程

    SpringCloud Feign傳遞HttpServletRequest對(duì)象流程

    HttpServletRequest接口的對(duì)象代表客戶端的請(qǐng)求，當(dāng)客戶端通過(guò)HTTP協(xié)議訪問(wèn)Tomcat服務(wù)器時(shí)，HTTP請(qǐng)求中的所有信息都封裝在HttpServletRequest接口的對(duì)象中，這篇文章介紹了Feign傳遞HttpServletRequest對(duì)象的流程，感興趣的同學(xué)可以參考下文
    2023-05-05
  • Java中如何獲取當(dāng)前服務(wù)器的IP地址

    Java中如何獲取當(dāng)前服務(wù)器的IP地址

    這篇文章主要給大家介紹了關(guān)于Java中如何獲取當(dāng)前服務(wù)器的IP地址的相關(guān)資料,我們可以使用Java中的InetAddress類(lèi)來(lái)獲取Linux服務(wù)器的IP地址,需要的朋友可以參考下
    2023-07-07
  • Java常用字符串工具類(lèi) 字符串智能截?。?）

    Java常用字符串工具類(lèi) 字符串智能截取（3）

    這篇文章主要為大家詳細(xì)介紹了Java常用字符串工具類(lèi)，字符串的智能截取，具有一定的參考價(jià)值，感興趣的小伙伴們可以參考一下
    2017-05-05
  • 簡(jiǎn)單講解Android開(kāi)發(fā)中觸摸和點(diǎn)擊事件的相關(guān)編程方法

    簡(jiǎn)單講解Android開(kāi)發(fā)中觸摸和點(diǎn)擊事件的相關(guān)編程方法

    這篇文章主要介紹了Android開(kāi)發(fā)中觸摸和點(diǎn)擊事件的相關(guān)編程方法,包括事件偵聽(tīng)器等安卓開(kāi)發(fā)中常用的接口的基本使用方法,需要的朋友可以參考下
    2015-12-12
  • JAVA多線程間通訊常用實(shí)現(xiàn)方法解析

    JAVA多線程間通訊常用實(shí)現(xiàn)方法解析

    這篇文章主要介紹了JAVA多線程間通訊常用實(shí)現(xiàn)方法解析,文中通過(guò)示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值,需要的朋友可以參考下
    2020-09-09
  • SpringBoot利用注解來(lái)實(shí)現(xiàn)Redis分布式鎖

    SpringBoot利用注解來(lái)實(shí)現(xiàn)Redis分布式鎖

    有些業(yè)務(wù)請(qǐng)求，屬于耗時(shí)操作，需要加鎖，防止后續(xù)的并發(fā)操作，同時(shí)對(duì)數(shù)據(jù)庫(kù)的數(shù)據(jù)進(jìn)行操作，需要避免對(duì)之前的業(yè)務(wù)造成影響。本文將利用注解來(lái)實(shí)現(xiàn)Redis分布式鎖，需要的可以參考一下
    2022-09-09
  • elasticsearch集群cluster示例詳解

    elasticsearch集群cluster示例詳解

    這篇文章主要為大家介紹了elasticsearch集群cluster示例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步，早日升職加薪
    2022-04-04
  • 一文帶你搞懂Java中的泛型和通配符

    一文帶你搞懂Java中的泛型和通配符

    泛型機(jī)制在項(xiàng)目中一直都在使用，甚至很多源碼中都用到了泛型機(jī)制。但是里面很多的機(jī)制和特性一直沒(méi)有明白，尤其通配符這塊，經(jīng)常忘記。本文對(duì)此做了一些總結(jié)，具有一定借鑒價(jià)值，希望有所幫助
    2022-09-09
  • SpringBoot連接Redis2種模式解析

    SpringBoot連接Redis2種模式解析

    這篇文章主要介紹了SpringBoot連接Redis2種模式解析,文中通過(guò)示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值,需要的朋友可以參考下
    2020-05-05

最新評(píng)論