為了了解鎖的工作方式，實現(xiàn)自定義鎖是一個好方法。 這篇文章將展示如何在Java上實現(xiàn)Filter和Bakery鎖（自旋鎖），并將它們的性能與Java的ReentrantLock進(jìn)行比較。 過濾器鎖和面包房鎖滿足互斥并且也是無饑餓算法，面包房鎖是先到先服務(wù)的鎖[1]。

為了進(jìn)行性能測試，使用不同的鎖類型，不同的線程數(shù)和不同的次數(shù)將計數(shù)器值遞增到10000000。 測試系統(tǒng)配置為：Intel Core I7（具有8個核心，其中4個是真實的），Ubuntu 14.04 LTS和Java 1.7.0_60。

過濾器鎖具有n-1個級別，可以視為“候診室”。 獲取鎖之前，必須有一個線程穿過此等候室。 級別[2]有兩個重要屬性：

至少一個嘗試進(jìn)入級別l的線程成功。

如果有多個線程試圖進(jìn)入級別l ，則至少一個線程被阻止（即繼續(xù)在該級別上等待）。

過濾器鎖定的實現(xiàn)如下：

/** * @author Furkan KAMACI */ public class Filter extends AbstractDummyLock implements Lock { /* Due to Java Memory Model, int[] not used for level and victim variables. Java programming language does not guarantee linearizability, or even sequential consistency, when reading or writing fields of shared objects [The Art of Multiprocessor Programming. Maurice Herlihy, Nir Shavit, 2008, pp.61.] */ private AtomicInteger[] level; private AtomicInteger[] victim; private int n; /** * Constructor for Filter lock * * @param n thread count */ public Filter(int n) { this.n = n; level = new AtomicInteger[n]; victim = new AtomicInteger[n]; for (int i = 0; i < n; i++) { level[i] = new AtomicInteger(); victim[i] = new AtomicInteger(); } } /** * Acquires the lock. */ @Override public void lock() { int me = ConcurrencyUtils.getCurrentThreadId(); for (int i = 1; i < n; i++) { level[me].set(i); victim[i].set(me); for (int k = 0; k < n; k++) { while ((k != me) && (level[k].get() >= i && victim[i].get() == me)) { //spin wait } } } } /** * Releases the lock. */ @Override public void unlock() { int me = ConcurrencyUtils.getCurrentThreadId(); level[me].set(0); } }

面包店鎖定算法通過使用面包店中常見的數(shù)字分配機的分布式版本來維護(hù)先到先得的屬性：每個線程在門口取一個數(shù)字，然后等待，直到?jīng)]有嘗試使用更早編號的線程為止輸入[3]。

面包店鎖的實現(xiàn)如下：

/** * @author Furkan KAMACI */ public class Bakery extends AbstractDummyLock implements Lock { /* Due to Java Memory Model, int[] not used for level and victim variables. Java programming language does not guarantee linearizability, or even sequential consistency, when reading or writing fields of shared objects [The Art of Multiprocessor Programming. Maurice Herlihy, Nir Shavit, 2008, pp.61.] */ private AtomicBoolean[] flag; private AtomicInteger[] label; private int n; /** * Constructor for Bakery lock * * @param n thread count */ public Bakery(int n) { this.n = n; flag = new AtomicBoolean[n]; label = new AtomicInteger[n]; for (int i = 0; i < n; i++) { flag[i] = new AtomicBoolean(); label[i] = new AtomicInteger(); } } /** * Acquires the lock. */ @Override public void lock() { int i = ConcurrencyUtils.getCurrentThreadId(); flag[i].set(true); label[i].set(findMaximumElement(label) + 1); for (int k = 0; k < n; k++) { while ((k != i) && flag[k].get() && ((label[k].get() < label[i].get()) || ((label[k].get() == label[i].get()) && k < i))) { //spin wait } } } /** * Releases the lock. */ @Override public void unlock() { flag[ConcurrencyUtils.getCurrentThreadId()].set(false); } /** * Finds maximum element within and {@link java.util.concurrent.atomic.AtomicInteger} array * * @param elementArray element array * @return maximum element */ private int findMaximumElement(AtomicInteger[] elementArray) { int maxValue = Integer.MIN_VALUE; for (AtomicInteger element : elementArray) { if (element.get() > maxValue) { maxValue = element.get(); } } return maxValue; } }

對于此類算法，應(yīng)提供或使用從0或1開始并以一個增量遞增的線程id系統(tǒng)。 線程的名稱為此目的進(jìn)行了適當(dāng)設(shè)置。 還應(yīng)該考慮：Java編程語言在讀取或?qū)懭牍蚕韺ο蟮淖侄螘r不能保證線性化甚至順序一致性[4]。 因此，過濾器鎖的級別和受害變量，面包店鎖的標(biāo)志和標(biāo)簽變量定義為原子變量。 一方面，想要測試Java內(nèi)存模型效果的人可以將該變量更改為int []和boolean []，并使用兩個以上的線程運行算法。 然后，可以看到即使線程處于活動狀態(tài)，該算法也將針對Filter或Bakery掛起。

為了測試算法性能，實現(xiàn)了一個自定義計數(shù)器類，該類具有g(shù)etAndIncrement方法，如下所示：

/** * gets and increments value up to a maximum number * * @return value before increment if it didn't exceed a defined maximum number. Otherwise returns maximum number. */ public long getAndIncrement() { long temp; lock.lock(); try { if (value >= maxNumber) { return value; } temp = value; value = temp + 1; } finally { lock.unlock(); } return temp; }

公平測試多個應(yīng)用程序配置存在最大的障礙。 考慮的是：有很多工作（將變量遞增到所需的數(shù)量），并且在線程數(shù)量不同的情況下，完成它的速度有多快。 因此，為了進(jìn)行比較，應(yīng)該有一個“工作”平等。 此方法還使用該代碼段測試不必要的工作負(fù)載：

if (value >= maxNumber) { return value; }

比較多個線程時，一種計算線程的單位工作性能的方法（即，不設(shè)置最大障礙，在循環(huán)中迭代到最大數(shù)量，然后將最后一個值除以線程數(shù)量）。

此配置用于性能比較：

線程數(shù)	1,2,3,4,5,6,7,8
重試計數(shù)	20
最大人數(shù)	10000000

這是包含標(biāo)準(zhǔn)誤差的結(jié)果圖表：

首先，當(dāng)您在Java中多次運行代碼塊時，會對代碼進(jìn)行內(nèi)部優(yōu)化。 當(dāng)算法多次運行并將第一輸出與第二輸出進(jìn)行比較時，可以看到此優(yōu)化的效果。 因此，第一次經(jīng)過的時間通常應(yīng)大于第二行。 例如：

currentTry = 0, threadCount = 1, maxNumber = 10000000, lockType = FILTER, elapsedTime = 500 (ms) currentTry = 1, threadCount = 1, maxNumber = 10000000, lockType = FILTER, elapsedTime = 433 (ms)

結(jié)論

從圖表中可以看出，面包房鎖比過濾器鎖快，標(biāo)準(zhǔn)誤差低。 原因是篩選器鎖定的鎖定方法。 在Bakery Lock中，作為一種公平的方法，線程是一個一個地運行的，但是在Filter Lock中，它們是相互計算的。 與其他Java相比，Java的ReentrantLock具有最佳的性能。

另一方面，Filter Lock線性地變差，但是Bakery和ReentrantLock卻不是（當(dāng)線程運行更多的線程時，Filter Lock可能具有線性圖形）。 更多的線程數(shù)并不意味著更少的經(jīng)過時間。 由于創(chuàng)建和鎖定/解鎖線程，因此2個線程可能比1個線程差。 當(dāng)線程數(shù)開始增加時，Bakery和ReentrantLock的經(jīng)過時間會變得更好。 但是，當(dāng)線程數(shù)持續(xù)增加時，它就會變得更糟。 原因是運行算法的測試計算機的真實核心編號。

• 可以從此處下載用于在Java中實現(xiàn)過濾器和面包店鎖的源代碼： https ： //github.com/kamaci/filbak

多處理器編程的藝術(shù)。 莫里斯·赫里希（Maurice Herlihy），《尼爾·沙維特》（Nir Shavit），2008年，第31.-33頁。

多處理器編程的藝術(shù)。 莫里斯·赫里希（Maurice Herlihy），《尼爾·沙維特》（Nir Shavit），2008年，第28頁。

多處理器編程的藝術(shù)。 莫里斯·赫利希（Maurice Herlihy），《尼爾·沙維特》（Nir Shavit），2008年，第31頁。

多處理器編程的藝術(shù)。 莫里斯·赫利希（Maurice Herlihy），《尼爾·沙維特》（Nir Shavit），2008年，第61頁。

翻譯自: https://www.javacodegeeks.com/2015/05/implementing-filter-and-bakery-locks-in-java.html

總結(jié)

以上是生活随笔為你收集整理的在Java中实现过滤器和面包店锁的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。