歡迎來到Linux教程網
Linux教程網
Linux教程網
Linux教程網
您现在的位置: Linux教程網 >> UnixLinux >  >> Linux編程 >> Linux編程

Java多線程-鎖

自 Java 5 開始,java.util.concurrent.locks 包中包含了一些鎖的實現,因此你不用去實現自己的鎖了。但是你仍然需要去了解怎樣使用這些鎖。

一個簡單的鎖

讓我們從 java 中的一個同步塊開始:

public class Counter{
    private int count = 0;

    public int inc(){
        synchronized(this){
            return ++count;
        }
    }
}

可以看到在 inc()方法中有一個 synchronized(this)代碼塊。該代碼塊可以保證在同一時間只有一個線程可以執行 return ++count。雖然在 synchronized 的同步塊中的代碼可以更加復雜,但是++count 這種簡單的操作已經足以表達出線程同步的意思。

以下的 Counter 類用 Lock 代替 synchronized 達到了同樣的目的:

public class Counter{
    private Lock lock = new Lock();
    private int count = 0;

    public int inc(){
        lock.lock();
        int newCount = ++count;
        lock.unlock();
        return newCount;
    }
}

lock()方法會對 Lock 實例對象進行加鎖,因此所有對該對象調用 lock()方法的線程都會被阻塞,直到該 Lock 對象的 unlock()方法被調用。

這裡有一個 Lock 類的簡單實現:

public class Counter{
public class Lock{
    private boolean isLocked = false;

    public synchronized void lock()
        throws InterruptedException{
        while(isLocked){
            wait();
        }
        isLocked = true;
    }

    public synchronized void unlock(){
        isLocked = false;
        notify();
    }
}

注意其中的 while(isLocked)循環,它又被叫做“自旋鎖”。當 isLocked 為 true 時,調用 lock()的線程在 wait()調用上阻塞等待。為防止該線程沒有收到 notify()調用也從 wait()中返回(也稱作虛假喚醒),這個線程會重新去檢查 isLocked 條件以決定當前是否可以安全地繼續執行還是需要重新保持等待,而不是認為線程被喚醒了就可以安全地繼續執行了。如果 isLocked 為 false,當前線程會退出 while(isLocked)循環,並將 isLocked 設回 true,讓其它正在調用 lock()方法的線程能夠在 Lock 實例上加鎖。

當線程完成了臨界區(位於 lock()和 unlock()之間)中的代碼,就會調用 unlock()。執行 unlock()會重新將 isLocked 設置為 false,並且通知(喚醒)其中一個(若有的話)在 lock()方法中調用了 wait()函數而處於等待狀態的線程。

鎖的可重入性

Java 中的 synchronized 同步塊是可重入的。這意味著如果一個 java 線程進入了代碼中的 synchronized 同步塊,並因此獲得了該同步塊使用的同步對象對應的管程上的鎖,那麼這個線程可以進入由同一個管程對象所同步的另一個 java 代碼塊。下面是一個例子:

public class Reentrant{
    public synchronized outer(){
        inner();
    }

    public synchronized inner(){
        //do something
    }
}

注意 outer()和 inner()都被聲明為 synchronized,這在 Java 中和 synchronized(this)塊等效。如果一個線程調用了 outer(),在 outer()裡調用 inner()就沒有什麼問題,因為這兩個方法(代碼塊)都由同一個管程對象(”this”)所同步。如果一個線程已經擁有了一個管程對象上的鎖,那麼它就有權訪問被這個管程對象同步的所有代碼塊。這就是可重入。線程可以進入任何一個它已經擁有的鎖所同步著的代碼塊。

前面給出的鎖實現不是可重入的。如果我們像下面這樣重寫 Reentrant 類,當線程調用 outer()時,會在 inner()方法的 lock.lock()處阻塞住。

public class Reentrant2{
    Lock lock = new Lock();

    public outer(){
        lock.lock();
        inner();
        lock.unlock();
    }

    public synchronized inner(){
        lock.lock();
        //do something
        lock.unlock();
    }
}

調用 outer()的線程首先會鎖住 Lock 實例,然後繼續調用 inner()。inner()方法中該線程將再一次嘗試鎖住 Lock 實例,結果該動作會失敗(也就是說該線程會被阻塞),因為這個 Lock 實例已經在 outer()方法中被鎖住了。

兩次 lock()之間沒有調用 unlock(),第二次調用 lock 就會阻塞,看過 lock()實現後,會發現原因很明顯:

public class Lock{
    boolean isLocked = false;

    public synchronized void lock()
        throws InterruptedException{
        while(isLocked){
            wait();
        }
        isLocked = true;
    }

    ...
}

一個線程是否被允許退出 lock()方法是由 while 循環(自旋鎖)中的條件決定的。當前的判斷條件是只有當 isLocked 為 false 時 lock 操作才被允許,而沒有考慮是哪個線程鎖住了它。

為了讓這個 Lock 類具有可重入性,我們需要對它做一點小的改動:

public class Lock{
    boolean isLocked = false;
    Thread  lockedBy = null;
    int lockedCount = 0;

    public synchronized void lock()
        throws InterruptedException{
        Thread callingThread =
            Thread.currentThread();
        while(isLocked && lockedBy != callingThread){
            wait();
        }
        isLocked = true;
        lockedCount++;
        lockedBy = callingThread;
  }

    public synchronized void unlock(){
        if(Thread.curentThread() ==
            this.lockedBy){
            lockedCount--;

            if(lockedCount == 0){
                isLocked = false;
                notify();
            }
        }
    }

    ...
}

注意到現在的 while 循環(自旋鎖)也考慮到了已鎖住該 Lock 實例的線程。如果當前的鎖對象沒有被加鎖(isLocked = false),或者當前調用線程已經對該 Lock 實例加了鎖,那麼 while 循環就不會被執行,調用 lock()的線程就可以退出該方法(譯者注:“被允許退出該方法”在當前語義下就是指不會調用 wait()而導致阻塞)。

除此之外,我們需要記錄同一個線程重復對一個鎖對象加鎖的次數。否則,一次 unblock()調用就會解除整個鎖,即使當前鎖已經被加鎖過多次。在 unlock()調用沒有達到對應 lock()調用的次數之前,我們不希望鎖被解除。

現在這個 Lock 類就是可重入的了。

鎖的公平性

Java 的 synchronized 塊並不保證嘗試進入它們的線程的順序。因此,如果多個線程不斷競爭訪問相同的 synchronized 同步塊,就存在一種風險,其中一個或多個線程永遠也得不到訪問權 —— 也就是說訪問權總是分配給了其它線程。這種情況被稱作線程饑餓。為了避免這種問題,鎖需要實現公平性。本文所展現的鎖在內部是用 synchronized 同步塊實現的,因此它們也不保證公平性。

在 finally 語句中調用 unlock()

如果用 Lock 來保護臨界區,並且臨界區有可能會拋出異常,那麼在 finally 語句中調用 unlock()就顯得非常重要了。這樣可以保證這個鎖對象可以被解鎖以便其它線程能繼續對其加鎖。以下是一個示例:

lock.lock();
try{
    //do critical section code,
    //which may throw exception
} finally {
    lock.unlock();
}

這個簡單的結構可以保證當臨界區拋出異常時 Lock 對象可以被解鎖。如果不是在 finally 語句中調用的 unlock(),當臨界區拋出異常時,Lock 對象將永遠停留在被鎖住的狀態,這會導致其它所有在該 Lock 對象上調用 lock()的線程一直阻塞。

Copyright © Linux教程網 All Rights Reserved