快捷導(dǎo)航

Android Lock鎖實(shí)現(xiàn)原理詳細(xì)分析

更新時(shí)間：2023年02月17日 09:53:10 作者：守住Android最后的光

這篇文章主要介紹了Android Lock鎖實(shí)現(xiàn)原理，Lock接口的實(shí)現(xiàn)類提供了比使用synchronized關(guān)鍵字更加靈活和廣泛的鎖定對(duì)象操作，而且是以面向?qū)ο蟮姆绞竭M(jìn)行對(duì)象加鎖

Lock簡(jiǎn)介

Lock接口位于J.U.C下locks包內(nèi)，其定義了Lock應(yīng)該具備的方法。

Lock 方法簽名：

void lock()：獲取鎖（不死不休，拿不到就一直等）
boolean tryLock()：獲取鎖（淺嘗輒止，拿不到就算了）
boolean tryLock(long time, TimeUnit unit) throws InterruptedException：獲取鎖（過(guò)時(shí)不候，在一定時(shí)間內(nèi)拿不到鎖，就算了）
void lockInterruptibly() throws InterruptedException：獲取鎖（任人擺布，xxx）
void unlock()：釋放鎖
Condition newCondition()：獲得Condition對(duì)象

synchronized和lock的區(qū)別

synchronized是java關(guān)鍵字，是用c++實(shí)現(xiàn)的；而lock是用java類，用java可以實(shí)現(xiàn)
synchronized可以鎖住代碼塊，對(duì)象和類，但是線程從開(kāi)始獲取鎖之后開(kāi)發(fā)者不能進(jìn)行控制和了解；lock則用起來(lái)非常靈活，提供了許多api可以讓開(kāi)發(fā)者去控制加鎖和釋放鎖等等。

寫(xiě)個(gè)Demo

static Lock lock = new ReentrantLock();
public static void main(String[] args) throws InterruptedException {         lock.lock();//其他沒(méi)拿到鎖的卡住不動(dòng)         Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("start to get lock Interruptibly");
                lock.unlock(); //看看會(huì)發(fā)生什么，注釋掉再看看
                lock.lock();
                System.out.println("拿到鎖");
                lock.unlock();
                System.out.println("釋放鎖");
            }
        });
        thread.start();         Thread.sleep(3000);
        lock.unlock();
    }

我們自己來(lái)手寫(xiě)一下lock接口的tryLock()、lock()和unLock()方法，實(shí)現(xiàn)我們自己的myLock。

public class MyLock implements Lock {
    //多并發(fā)調(diào)用  0-未占用 大于0-占用
    AtomicInteger state = new AtomicInteger();     Thread ownerThread = new Thread();     //等待鎖的隊(duì)列
    LinkedBlockingQueue<Thread> waiters = new LinkedBlockingQueue();     @Override
    public void lock() {
        if (!tryLock()) {  //先搶鎖，所以是非公平鎖
            //沒(méi)拿到鎖,放到隊(duì)列中去進(jìn)行排隊(duì)
            waiters.add(Thread.currentThread());
            //等待被喚醒
            for (; ; ) {
                if (tryLock()) {  //非公平鎖情況下，喚醒過(guò)來(lái)繼續(xù)獲取鎖
                    waiters.poll(); //獲取鎖成功把自己從隊(duì)列中取出來(lái)
                    return;
                } else    //獲取鎖失敗
                    LockSupport.park();  //線程阻塞
            }
        }
    }     @Override
    public boolean tryLock() {
        if (state.get() == 0) { //如果鎖沒(méi)被占用
            if (state.compareAndSet(0, 1)) {  //如果成功拿到鎖
                ownerThread = Thread.currentThread();   //占用鎖線程改為當(dāng)前線程
                return true;
            }
        }
        return false;
    }     @Override
    public void unlock() {         if (ownerThread != Thread.currentThread())  //占用鎖線程不是當(dāng)前線程無(wú)法釋放鎖
            throw new RuntimeException("非法調(diào)用,當(dāng)前鎖不屬于你");         if (state.decrementAndGet() == 0)  //如果成功釋放鎖
            ownerThread = null;  //占用鎖線程置空
        //通知其他線程
//        Thread thread = null;
//
//        while ((thread = waiters.peek()) != null)
//            LockSupport.unpark(thread);
        Thread thread = waiters.peek(); //獲取隊(duì)列頭部線程，線程還留在隊(duì)列中
        if (thread != null) {
            LockSupport.unpark(thread); //取消阻塞
        }
    }     @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }     @Override
    public Condition newCondition() {
        return null;
    }     @Override
    public void lockInterruptibly() throws InterruptedException {     }
}

幾個(gè)注意點(diǎn)：

鎖的占用狀態(tài)state是AtomicInteger類型，底層原理是CAS，這是為了保證在多并發(fā)情況下線程安全問(wèn)題；
當(dāng)線程1釋放鎖成功時(shí)，獲取隊(duì)列頭部線程但并不取出，因?yàn)榉枪芥i模式下，隊(duì)列頭部線程不一定能獲取到鎖；
LockSupport的park()和unPark()方法是native方法，可以阻塞，喚醒線程；

Lock默認(rèn)是非公平鎖，上面實(shí)現(xiàn)的也是非公平鎖，小伙伴們可以試一試。

公平鎖和非公平鎖區(qū)別：

先等待先獲取鎖是公平鎖；先等待也不一定先獲取鎖，可能被突然到來(lái)的線程獲取到是非公平鎖；

公平鎖的實(shí)現(xiàn)：

  @Override
    public void lock() {
       checkQueue（）;//線程來(lái)的時(shí)候先不獲取鎖，而是先檢查隊(duì)列中有沒(méi)有等待的線程，如果有，直接放入隊(duì)列，如果沒(méi)有，再去獲取鎖
        if (!tryLock()) {  //先搶鎖，所以是非公平鎖
            //沒(méi)拿到鎖,放到隊(duì)列中去進(jìn)行排隊(duì)
            waiters.add(Thread.currentThread());
            //等待被喚醒
            for (; ; ) {
                if (tryLock()) {  //非公平鎖情況下，喚醒過(guò)來(lái)繼續(xù)獲取鎖
                    waiters.poll(); //獲取鎖成功把自己從隊(duì)列中取出來(lái)
                    return;
                } else    //獲取鎖失敗
                    LockSupport.park();  //線程阻塞
            }
        }
    }

lock源碼

在閱讀源碼的成長(zhǎng)的過(guò)程中，有很多人會(huì)遇到很多困難，一個(gè)是源碼太多，另一方面是源碼看不懂。在閱讀源碼方面，我提供一些個(gè)人的建議：

第一個(gè)是抓主舍次，看源碼的時(shí)候，很多人會(huì)發(fā)現(xiàn)源碼太長(zhǎng)太多，看不下去，這就要求我們抓住哪些是核心的方法，哪些是次要的方法。當(dāng)舍去次要方法，就會(huì)發(fā)現(xiàn)代碼精簡(jiǎn)和很多，會(huì)大大提高我們閱讀源碼的信心。
第二個(gè)是不要死扣，有人看源碼會(huì)一行一行的死扣，當(dāng)看到某一行看不懂，就一直停在那里死扣，知道看懂為止，其實(shí)很多時(shí)候，雖然看不懂代碼，但是可以從變量名和方法名知道該代碼的作用，java中都是見(jiàn)名知意的。

接下來(lái)進(jìn)入閱讀lock的源碼部分，在lock的接口中，主要的方法如下：

public interface Lock {
    // 加鎖
    void lock()；
    // 嘗試獲取鎖
    boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    // 解鎖
    void unlock();
}

在lock接口的實(shí)現(xiàn)類中，最主要的就是ReentrantLock，來(lái)看看ReentrantLock中lock()方法的源碼：

    // 默認(rèn)構(gòu)造方法，非公平鎖
    public ReentrantLock() {
        sync = new NonfairSync();
    }
    // 構(gòu)造方法，公平鎖
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }
    // 加鎖
    public void lock() {
        sync.lock();
    }

在初始化lock實(shí)例對(duì)象的時(shí)候，可以提供一個(gè)boolean的參數(shù)，也可以不提供該參數(shù)。提供該參數(shù)就是公平鎖，不提供該參數(shù)就是非公平鎖。

總結(jié)

lock的存儲(chǔ)結(jié)構(gòu)：一個(gè)int類型狀態(tài)值（用于鎖的狀態(tài)變更），一個(gè)雙向鏈表（用于存儲(chǔ)等待中的線程）
lock獲取鎖的過(guò)程：本質(zhì)上是通過(guò)CAS來(lái)獲取狀態(tài)值修改，如果當(dāng)場(chǎng)沒(méi)獲取到，會(huì)將該線程放在線程等待鏈表中。
lock釋放鎖的過(guò)程：修改狀態(tài)值，調(diào)整等待鏈表。

到此這篇關(guān)于Android Lock鎖實(shí)現(xiàn)原理詳細(xì)分析的文章就介紹到這了,更多相關(guān)Android Lock鎖內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: