<em>Mac</em>Book项目 2009年学校开始实施<em>Mac</em>Book项目,所有师生配备一本<em>Mac</em>Book,并同步更新了校园无线网络。学校每周进行电脑技术更新,每月发送技术支持资料,极大改变了教学及学习方式。因此2011
2021-06-01 09:32:01
Java多執行緒之鎖學習(增強版)
2023-02-27 06:00:16
阻塞鎖
含義：多個執行緒同時呼叫一個方法的時候，所有的執行緒都被排隊處理了，讓執行緒進入阻塞狀態進行等待，當獲得相應的訊號（喚醒、時間）時，才能進入執行緒的準備就緒的狀態。通過競爭。進入執行狀態。
Java中，能夠進入退出、阻塞狀態或包含阻塞鎖的方法有 ，synchronized 關鍵字（其中的重量鎖），ReentrantLock，Object.wait()notify()
範例程式碼如下
// 在main方法中，開啟100個執行緒執行 lock() 方法
// 開啟10個執行緒執行 unlock() 方法
// 此時進行加鎖和解鎖之後，加鎖多於解鎖的時候，就會一直阻塞等待
public class Demo01 {
private boolean isLocked = false;
public synchronized void lock() throws InterruptedException {
while (isLocked) {
// 當其他執行緒進來，即處於等待阻塞狀態
wait();
}
System.out.println("Demo01.lock");
isLocked = true;
}
public synchronized void unlock() {
isLocked = false;
System.out.println("Demo01.unlock");
notify();
}
public static void main(String[] args) {
Demo01 demo01 = new Demo01();
for (int i = 0; i < 100; i++) {
new Thread(() -> {
try {
demo01.lock();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
for (int i = 0; i < 10; i++) {
new Thread(() -> {
demo01.unlock();
}).start();
}
}
}由於被呼叫的方法越耗時，執行緒越多的時候，等待的執行緒等待的時間也就越長，甚至於幾分鐘或者幾十分鐘。對於Web等對反應時間要求很高的系統來說，這是不可行的，因此需要讓其非阻塞，可以在沒有拿到鎖之後馬上返回，告訴客戶稍後重試。
非阻塞鎖
含義：多個執行緒同時呼叫一個方法的時候，當某一個執行緒最先獲取到鎖，這時其他執行緒沒拿到鎖，這時就直接返回，只有當最先獲取的鎖的執行緒釋放鎖，其他執行緒的鎖才能進來，在它釋放之前其他執行緒都會獲取失敗
程式碼實現如下
// 非阻塞鎖
public class Demo02 {
private boolean isLocked = false;
public synchronized boolean lock() throws InterruptedException {
if (isLocked) {
return false;
}
System.out.println("Demo01.lock");
isLocked = true;
return true;
}
public synchronized boolean unlock() {
if (isLocked) {
System.out.println("Demo01.unlock");
isLocked = !isLocked;
return true;
}
return false;
}
public static void main(String[] args) {
Demo02 demo01 = new Demo02();
for (int i = 0; i < 100; i++) {
new Thread(() -> {
try {
if (demo01.lock()) {
System.out.println("獲取鎖失敗");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
for (int i = 0; i < 1000; i++) {
new Thread(() -> {
if (demo01.unlock()) {
System.out.println("解鎖成功");
}
}).start();
}
}
}鎖的四種狀態
鎖的狀態總共有四種：無鎖狀態、偏向鎖、輕量級鎖和重量級鎖。隨著鎖的競爭，鎖可以從偏向鎖升級到輕量級鎖，再升級的重量級鎖（但是鎖的升級是單向的，也就是說只能從低到高升級，不會出現鎖的降級）JDK 1.6中預設是開啟偏向鎖和輕量級鎖的，
注意：HotSpot JVM是支援鎖降級的 但是因為降級的效率太低了，所以在開發中不使用降級的操作
但是鎖的狀態時存在哪裡的呢？
鎖存在Java的物件頭中的Mark Work。Mark Work預設不僅存放著鎖標誌位，還存放物件hashCode等資訊。執行時，會根據鎖的狀態，修改Mark Work的儲存內容。如果物件是陣列型別，則虛擬機器器用3個字寬儲存物件頭，如果物件是非陣列型別，則用2字寬儲存物件頭。在32位元虛擬機器器中，一字寬等於四位元組，即32bit。
字寬（Word）: 記憶體大小的單位概念， 對於 32 位處理器 1 Word = 4 Bytes， 64 位處理器 1 Word = 8 Bytes
每一個 Java 物件都至少佔用 2 個字寬的記憶體(陣列型別佔用3個字寬)。
- 第一個字寬也被稱為物件頭Mark Word。 物件頭包含了多種不同的資訊， 其中就包含物件鎖相關的資訊。
- 第二個字寬是指向定義該物件類資訊（class metadata）的指標
無鎖狀態
在程式碼剛剛進入同步塊的時候，就處於無鎖狀態。
偏向鎖
概念：偏向鎖會偏向於第一個存取鎖的執行緒，如果在接下來的執行過程中，該鎖沒有被其他的執行緒存取，則持有偏向鎖的執行緒將永遠不需要觸發同步。也就是說，偏向鎖在資源無競爭的情況下消除了同步語句，連CAS操作都不做了，提高了程式的執行效能
引入偏向鎖是為了在無多執行緒競爭的情況下儘量減少不必要的輕量鎖執行路徑。因為輕量級鎖的獲取以及釋放依賴多次CAS原子指令，而偏向鎖只需要在置換ThreadID的時候依賴一次原子指令（由於一旦出現多執行緒競爭的情況就必須復原偏向鎖，所以偏向鎖的復原操作的效能損耗必須小於節省下來的CAS原子指令的效能消耗）上面說過，輕量級鎖是為了在多執行緒交替執行同步塊時提高效能，而偏向鎖則是在只有一個執行緒執行同步塊的時候進一步提高效能。
輕量級鎖
“輕量級”是相對於使用作業系統互斥量來實現傳統鎖而言的。但是首先需要強調一點的是，輕量級鎖並不是用來代替重量級鎖的，它的本意是在沒有多執行緒競爭的前提下，減少傳統的重量級鎖使用產生的效能消耗。
在解釋輕量級鎖的執行過程過程之前，我們要先明白一點，輕量級鎖使用的場景是執行緒交替同步塊的情況，如果存在同一時間存取同一鎖的情況，就會導致輕量級鎖膨脹為重量級。
重量級鎖
synchronized是通過物件內部的一個監視器鎖（monitor）實現的。但是monitor底層又依賴於底層作業系統的Mutex Lock實現的。而作業系統實現執行緒之間的切換就需要從使用者態切換到核心態，切換的成本很高，狀態之間的轉化需要相對比較長的時間，這就是synchronized效率低的原因，因此，這種依賴於作業系統的Mutex Lock所實現的鎖被稱之為“重量級鎖”
可重入鎖
可重入鎖也叫做遞迴鎖，指的是同一執行緒外層函數獲得鎖之後，記憶體遞迴函數仍然有獲得該鎖的程式碼，但是不受影響
Java中ReentrantLock和synchronized都是可重入鎖 自旋鎖不是可重入鎖
可重入鎖的最大作用就是避免死鎖
下面是一段範例程式碼
public class Test implements Runnable {
public synchronized void get() {
System.out.println(Thread.currentThread().getId());
set();
}
public synchronized void set() {
System.out.println(Thread.currentThread().getId());
}
@Override
public void run() {
get();
}
public static void main(String[] args) {
Test ss = new Test();
new Thread(ss).start();
new Thread(ss).start();
new Thread(ss).start();
}
}
// 執行結果
// 11
// 11
// 12
// 12
// 13
// 13
public class Test2 implements Runnable {
ReentrantLock lock = new ReentrantLock();
public void get() {
lock.lock();
try {
System.out.println(Thread.currentThread().getId());
set();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void set() {
lock.lock();
try {
System.out.println(Thread.currentThread().getId());
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
@Override
public void run() {
get();
}
public static void main(String[] args) {
Test ss = new Test();
new Thread(ss).start();
new Thread(ss).start();
new Thread(ss).start();
}
}
// 執行結果
// 11
// 11
// 12
// 12
// 13
// 13
自旋鎖
public class SpinLock {
private AtomicReference<Thread> owner = new AtomicReference<>();
public void lock() {
Thread current = Thread.currentThread();
while (!owner.compareAndSet(null, current)) {
}
}
public void unlock() {
Thread current = Thread.currentThread();
owner.compareAndSet(current, null);
}
改進的自旋鎖
public class SpinLock1 {
private AtomicReference<Thread> owner =new AtomicReference<>();
private int count =0;
public void lock(){
Thread current = Thread.currentThread();
if(current==owner.get()) {
count++;
return ;
}
while(!owner.compareAndSet(null, current)){
}
}
public void unlock (){
Thread current = Thread.currentThread();
if(current==owner.get()){
if(count!=0){
count--;
}else{
owner.compareAndSet(current, null);
}
}
}
}讀寫鎖
Lock介面以及其物件，使用它，很優雅的控制了競爭資源的安全存取，但是這種鎖不區別讀寫 - 為普通鎖
為了提高效能，Java提供了讀寫鎖，在讀的地方使用讀鎖，在寫的時候使用寫鎖，靈活控制，如果沒有寫鎖的情況下。讀是無阻塞的，在一定情況下提高了程式的執行效率。下面我們來看原始碼（Lock介面和Condition介面在上一篇Java - 多執行緒 - 鎖和提升 第1篇已經分析過，此處不再分析）
public class ReentrantReadWriteLock
implements ReadWriteLock, java.io.Serializable {
private static final long serialVersionUID = -6992448646407690164L;
// 讀鎖內部類物件
private final ReentrantReadWriteLock.ReadLock readerLock;
// 寫鎖內部類物件
private final ReentrantReadWriteLock.WriteLock writerLock;
// 執行所有的同步機制
final Sync sync;
// 無參建構函式 呼叫有參構造 ReentrantReadWriteLock(boolean fair)
public ReentrantReadWriteLock() {
this(false);
}
// 有參建構函式 是否建立公平鎖
public ReentrantReadWriteLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
readerLock = new ReadLock(this);
writerLock = new WriteLock(this);
}
// 返回讀鎖和寫鎖的物件
public ReentrantReadWriteLock.WriteLock writeLock() { return writerLock; }
public ReentrantReadWriteLock.ReadLock readLock() { return readerLock; }
// 繼承自 AbstractQueueSynchronizer 的Sync
abstract static class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = 6317671515068378041L;
// 共用移位
static final int SHARED_SHIFT = 16;
// 共用單位
static final int SHARED_UNIT = (1 << SHARED_SHIFT);
// 最大數量
static final int MAX_COUNT = (1 << SHARED_SHIFT) - 1;
// 獨佔
static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;
// 返回共用鎖的數量
static int sharedCount(int c) { return c >>> SHARED_SHIFT; }
// 返回獨佔鎖的數量
static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }
// 每執行緒讀取保持計數的計數器
static final class HoldCounter {
int count = 0;
// 使用id 而不是使用參照 避免垃圾殘留
final long tid = getThreadId(Thread.currentThread());
}
// 執行緒本地子類
static final class ThreadLocalHoldCounter
extends ThreadLocal<HoldCounter> {
public HoldCounter initialValue() {
return new HoldCounter();
}
}
// 當前執行緒持有的可重入鎖的數量，只在建構函式和readObject中初始化，
// 當執行緒的讀取保持計數下降到0的時候刪除
private transient ThreadLocalHoldCounter readHolds;
// 獲取readLock的最後一個執行緒的保持計數
private transient HoldCounter cachedHoldCounter;
// 第一個獲得讀的執行緒
private transient Thread firstReader = null;
// 計數器
private transient int firstReaderHoldCount;
Sync() {
readHolds = new ThreadLocalHoldCounter();
setState(getState()); // ensures visibility of readHolds
}
// 當前執行緒獲取鎖的時候由於策略超過其他等待執行緒而應阻止，返回true
abstract boolean readerShouldBlock();
// 如果由於試圖超越其他等待執行緒的策略而導致當前執行緒在嘗試獲取寫鎖（且有資格這樣做）
// 時應阻塞，則返回true
abstract boolean writerShouldBlock();
// 嘗試釋放
protected final boolean tryRelease(int releases) {
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
int nextc = getState() - releases;
boolean free = exclusiveCount(nextc) == 0;
if (free)
setExclusiveOwnerThread(null);
setState(nextc);
return free;
}
// 嘗試增加
protected final boolean tryAcquire(int acquires) {
/*
* Walkthrough:
* 1. If read count nonzero or write count nonzero
* and owner is a different thread, fail.
* 2. If count would saturate, fail. (This can only
* happen if count is already nonzero.)
* 3. Otherwise, this thread is eligible for lock if
* it is either a reentrant acquire or
* queue policy allows it. If so, update state
* and set owner.
*/
Thread current = Thread.currentThread();
int c = getState();
int w = exclusiveCount(c);
if (c != 0) {
// (Note: if c != 0 and w == 0 then shared count != 0)
if (w == 0 || current != getExclusiveOwnerThread())
return false;
if (w + exclusiveCount(acquires) > MAX_COUNT)
throw new Error("Maximum lock count exceeded");
// Reentrant acquire
setState(c + acquires);
return true;
}
if (writerShouldBlock() ||
!compareAndSetState(c, c + acquires))
return false;
setExclusiveOwnerThread(current);
return true;
}
// 嘗試釋放共用鎖
protected final boolean tryReleaseShared(int unused) {
Thread current = Thread.currentThread();
if (firstReader == current) {
// assert firstReaderHoldCount > 0;
if (firstReaderHoldCount == 1)
firstReader = null;
else
firstReaderHoldCount--;
} else {
HoldCounter rh = cachedHoldCounter;
if (rh == null || rh.tid != getThreadId(current))
rh = readHolds.get();
int count = rh.count;
if (count <= 1) {
readHolds.remove();
if (count <= 0)
throw unmatchedUnlockException();
}
--rh.count;
}
for (;;) {
int c = getState();
int nextc = c - SHARED_UNIT;
if (compareAndSetState(c, nextc))
// Releasing the read lock has no effect on readers,
// but it may allow waiting writers to proceed if
// both read and write locks are now free.
return nextc == 0;
}
}
// 非法的監視器狀態異常
private IllegalMonitorStateException unmatchedUnlockException() {
return new IllegalMonitorStateException(
"attempt to unlock read lock, not locked by current thread");
}
// 嘗試加共用鎖
protected final int tryAcquireShared(int unused) {
/*
* Walkthrough:
* 1. If write lock held by another thread, fail.
* 2. Otherwise, this thread is eligible for
* lock wrt state, so ask if it should block
* because of queue policy. If not, try
* to grant by CASing state and updating count.
* Note that step does not check for reentrant
* acquires, which is postponed to full version
* to avoid having to check hold count in
* the more typical non-reentrant case.
* 3. If step 2 fails either because thread
* apparently not eligible or CAS fails or count
* saturated, chain to version with full retry loop.
*/
Thread current = Thread.currentThread();
int c = getState();
if (exclusiveCount(c) != 0 &&
getExclusiveOwnerThread() != current)
return -1;
int r = sharedCount(c);
if (!readerShouldBlock() &&
r < MAX_COUNT &&
compareAndSetState(c, c + SHARED_UNIT)) {
if (r == 0) {
firstReader = current;
firstReaderHoldCount = 1;
} else if (firstReader == current) {
firstReaderHoldCount++;
} else {
HoldCounter rh = cachedHoldCounter;
if (rh == null || rh.tid != getThreadId(current))
cachedHoldCounter = rh = readHolds.get();
else if (rh.count == 0)
readHolds.set(rh);
rh.count++;
}
return 1;
}
return fullTryAcquireShared(current);
}
// 讀取的完整版本，可處理CAS丟失和tryAcquireShared中未處理的可重入讀取
final int fullTryAcquireShared(Thread current) {
HoldCounter rh = null;
for (;;) {
int c = getState();
if (exclusiveCount(c) != 0) {
if (getExclusiveOwnerThread() != current)
return -1;
} else if (readerShouldBlock()) {
if (firstReader == current) {
// assert firstReaderHoldCount > 0;
} else {
if (rh == null) {
rh = cachedHoldCounter;
if (rh == null || rh.tid != getThreadId(current)) {
rh = readHolds.get();
if (rh.count == 0)
readHolds.remove();
}
}
if (rh.count == 0)
return -1;
}
}
if (sharedCount(c) == MAX_COUNT)
throw new Error("Maximum lock count exceeded");
if (compareAndSetState(c, c + SHARED_UNIT)) {
if (sharedCount(c) == 0) {
firstReader = current;
firstReaderHoldCount = 1;
} else if (firstReader == current) {
firstReaderHoldCount++;
} else {
if (rh == null)
rh = cachedHoldCounter;
if (rh == null || rh.tid != getThreadId(current))
rh = readHolds.get();
else if (rh.count == 0)
readHolds.set(rh);
rh.count++;
cachedHoldCounter = rh; // cache for release
}
return 1;
}
}
}
// 執行tryLock進行寫入，從而在兩種模式下都可以進行插入，這與tryAcquire的作用相同
// 只是缺少對 writerShouldBlock的呼叫
final boolean tryWriteLock() {
Thread current = Thread.currentThread();
int c = getState();
if (c != 0) {
int w = exclusiveCount(c);
if (w == 0 || current != getExclusiveOwnerThread())
return false;
if (w == MAX_COUNT)
throw new Error("Maximum lock count exceeded");
}
if (!compareAndSetState(c, c + 1))
return false;
setExclusiveOwnerThread(current);
return true;
}
// 執行tryLock進行讀取，從而在兩種模式下都可以進行插入。
// 除了沒有呼叫readerReaderShouldBlock以外，這與tryAcquireShared的作用相同。
final boolean tryReadLock() {
Thread current = Thread.currentThread();
for (;;) {
int c = getState();
if (exclusiveCount(c) != 0 &&
getExclusiveOwnerThread() != current)
return false;
int r = sharedCount(c);
if (r == MAX_COUNT)
throw new Error("Maximum lock count exceeded");
if (compareAndSetState(c, c + SHARED_UNIT)) {
if (r == 0) {
firstReader = current;
firstReaderHoldCount = 1;
} else if (firstReader == current) {
firstReaderHoldCount++;
} else {
HoldCounter rh = cachedHoldCounter;
if (rh == null || rh.tid != getThreadId(current))
cachedHoldCounter = rh = readHolds.get();
else if (rh.count == 0)
readHolds.set(rh);
rh.count++;
}
return true;
}
}
}
// 是否獨佔鎖
protected final boolean isHeldExclusively() {
return getExclusiveOwnerThread() == Thread.currentThread();
}
// 返回Condition物件
final ConditionObject newCondition() {
return new ConditionObject();
}
// 返回獨佔鎖
final Thread getOwner() {
return ((exclusiveCount(getState()) == 0) ?
null :
getExclusiveOwnerThread());
}
// 獲取readLock所得個數
final int getReadLockCount() {
return sharedCount(getState());
}
// 判斷是否是 writeLock 鎖
final boolean isWriteLocked() {
return exclusiveCount(getState()) != 0;
}
// 獲得寫鎖的數量
final int getWriteHoldCount() {
return isHeldExclusively() ? exclusiveCount(getState()) : 0;
}
// 獲得讀鎖的數量
final int getReadHoldCount() {
if (getReadLockCount() == 0)
return 0;
Thread current = Thread.currentThread();
if (firstReader == current)
return firstReaderHoldCount;
HoldCounter rh = cachedHoldCounter;
if (rh != null && rh.tid == getThreadId(current))
return rh.count;
int count = readHolds.get().count;
if (count == 0) readHolds.remove();
return count;
}
// 序列化
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();
readHolds = new ThreadLocalHoldCounter();
setState(0); // reset to unlocked state
}
// 獲取數量
final int getCount() { return getState(); }
}
// 非公平鎖
static final class NonfairSync extends Sync {
private static final long serialVersionUID = -8159625535654395037L;
final boolean writerShouldBlock() {
return false; // writers can always barge
}
final boolean readerShouldBlock() {
return apparentlyFirstQueuedIsExclusive();
}
}
// 公平鎖
static final class FairSync extends Sync {
private static final long serialVersionUID = -2274990926593161451L;
final boolean writerShouldBlock() {
return hasQueuedPredecessors();
}
final boolean readerShouldBlock() {
return hasQueuedPredecessors();
}
}
// 讀鎖實現了 Lock 介面
public static class ReadLock implements Lock, java.io.Serializable {
private static final long serialVersionUID = -5992448646407690164L;
private final Sync sync;
// 初始化，獲得是否是公平讀鎖
protected ReadLock(ReentrantReadWriteLock lock) {
sync = lock.sync;
}
// 加鎖 是共用鎖
public void lock() {
sync.acquireShared(1);
}
// 鎖中斷
public void lockInterruptibly() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
// 呼叫加鎖
public boolean tryLock() {
return sync.tryReadLock();
}
// 超時加鎖
public boolean tryLock(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}
// 解鎖
public void unlock() {
sync.releaseShared(1);
}
// Condition 物件
public Condition newCondition() {
throw new UnsupportedOperationException();
}
// toString方法
public String toString() {
int r = sync.getReadLockCount();
return super.toString() +
"[Read locks = " + r + "]";
}
}
// 寫鎖
public static class WriteLock implements Lock, java.io.Serializable {
private static final long serialVersionUID = -4992448646407690164L;
private final Sync sync;
// 寫鎖初始化
protected WriteLock(ReentrantReadWriteLock lock) {
sync = lock.sync;
}
// 加鎖
public void lock() {
sync.acquire(1);
}
// 鎖中斷
public void lockInterruptibly() throws InterruptedException {
sync.acquireInterruptibly(1);
}
// 加鎖
public boolean tryLock( ) {
return sync.tryWriteLock();
}
// 超時加鎖
public boolean tryLock(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}
// 解鎖，呼叫 release 減1
public void unlock() {
sync.release(1);
}
// Condition物件
public Condition newCondition() {
return sync.newCondition();
}
// toString方法
public String toString() {
Thread o = sync.getOwner();
return super.toString() + ((o == null) ?
"[Unlocked]" :
"[Locked by thread " + o.getName() + "]");
}
// 是否有獨佔的執行緒
public boolean isHeldByCurrentThread() {
return sync.isHeldExclusively();
}
// 獲取寫鎖的數量
public int getHoldCount() {
return sync.getWriteHoldCount();
}
}
// 判斷是否是公平鎖
public final boolean isFair() {
return sync instanceof FairSync;
}
// 判斷是否是獨佔鎖
protected Thread getOwner() {
return sync.getOwner();
}
// 獲取讀鎖的個數
public int getReadLockCount() {
return sync.getReadLockCount();
}
// 判斷是否是寫鎖
public boolean isWriteLocked() {
return sync.isWriteLocked();
}
// 判斷鎖是否被當前執行緒持有
public boolean isWriteLockedByCurrentThread() {
return sync.isHeldExclusively();
}
// 查詢當前執行緒對該鎖的可重入寫入次數
public int getWriteHoldCount() {
return sync.getWriteHoldCount();
}
// 查詢當前執行緒對該鎖的可重讀次數
public int getReadHoldCount() {
return sync.getReadHoldCount();
}
// 返回寫執行緒的集合
protected Collection<Thread> getQueuedWriterThreads() {
return sync.getExclusiveQueuedThreads();
}
// 返回讀執行緒的集合
protected Collection<Thread> getQueuedReaderThreads() {
return sync.getSharedQueuedThreads();
}
// 查詢是否有任何執行緒正在等待獲取讀或寫鎖
public final boolean hasQueuedThreads() {
return sync.hasQueuedThreads();
}
// 查詢指定執行緒是否在等待讀或者寫鎖
public final boolean hasQueuedThread(Thread thread) {
return sync.isQueued(thread);
}
// 獲取等待佇列的長度
public final int getQueueLength() {
return sync.getQueueLength();
}
// 獲得等待佇列中的執行緒集合
protected Collection<Thread> getQueuedThreads() {
return sync.getQueuedThreads();
}
// 查詢是否有任何執行緒正在等待與寫鎖關聯的給定條件
public boolean hasWaiters(Condition condition) {
if (condition == null)
throw new NullPointerException();
if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
throw new IllegalArgumentException("not owner");
return sync.hasWaiters((AbstractQueuedSynchronizer.ConditionObject)condition);
}
// 查詢是否有任何執行緒正在等待與寫鎖關聯的給定條件的長度
public int getWaitQueueLength(Condition condition) {
if (condition == null)
throw new NullPointerException();
if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
throw new IllegalArgumentException("not owner");
return sync.getWaitQueueLength((AbstractQueuedSynchronizer.ConditionObject)condition);
}
// 獲得給定條件等待執行緒的集合
protected Collection<Thread> getWaitingThreads(Condition condition) {
if (condition == null)
throw new NullPointerException();
if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
throw new IllegalArgumentException("not owner");
return sync.getWaitingThreads((AbstractQueuedSynchronizer.ConditionObject)condition);
}
// toString()方法
public String toString() {
int c = sync.getCount();
int w = Sync.exclusiveCount(c);
int r = Sync.sharedCount(c);
return super.toString() +
"[Write locks = " + w + ", Read locks = " + r + "]";
}
// 獲取執行緒ID
static final long getThreadId(Thread thread) {
return UNSAFE.getLongVolatile(thread, TID_OFFSET);
}
// Unsafe物件
private static final sun.misc.Unsafe UNSAFE;
private static final long TID_OFFSET;
static {
try {
UNSAFE = sun.misc.Unsafe.getUnsafe();
Class<?> tk = Thread.class;
TID_OFFSET = UNSAFE.objectFieldOffset
(tk.getDeclaredField("tid"));
} catch (Exception e) {
throw new Error(e);
}
}
}
總結：
- 從讀寫鎖的實現程式碼，我們可以看到，其本質還是使用了AQS的獨佔鎖和共用鎖實現了讀寫分離。
- 當需要進行讀的時候使用共用鎖，當需要寫的時候使用獨佔鎖
- 同時，ReentrantReadWriteLock也提供了預設的非公平機制，當然也可以使用構造方法設定是否是公平鎖
互斥鎖
互斥鎖指的是一次最多隻能有一個執行緒持有的鎖。如Java的Lock
互斥鎖也是為了保護共用資源的同步，在任何時刻，最多隻能有一個保持者，也就說，在任何時刻最多隻能有一個執行單元獲得鎖。互斥鎖和自旋鎖在排程機制上略有不同。對於互斥鎖，如果資源已經被佔用，資源申請者只能進入睡眠狀態。但是自旋鎖不會引起呼叫者睡眠，如果自旋鎖已經被別的執行單元保持，呼叫者就一直迴圈在那裡看是否該自旋鎖的保持者已經釋放了鎖。
悲觀鎖
悲觀鎖，顧名思義就是狠悲觀，認為每次拿去的資料都會被修改，所以在每次拿鎖的時候都會上鎖，這樣別人想拿到這個資料就會block到直到他拿到鎖。傳統的資料庫就使用了很多的這種的機制：如行鎖、表鎖、讀鎖、寫鎖等，都是在做操作之前上鎖。共用鎖、排他鎖、獨佔鎖是悲觀鎖的一種實現。
Java中的悲觀鎖，最典型的就是synchronized。而AQS框架下的鎖，先嚐試使用CAS樂觀鎖去獲取鎖，獲取不到才會轉為悲觀鎖，如ReentrantLock
樂觀鎖
樂觀鎖，顧名思義就是很樂觀，每次拿去的資料都認為不會被修改，所以不會上鎖。但是在更新的時候會判斷一下在此期間別人有沒有去更新這個資料，對於此過程出現的ABA問題，可以使用版本號進行控制。
樂觀鎖用於多讀的場景，資料庫提供的類似於write_condition機制都是使用了樂觀鎖，使用CAS保證這個操作的原子性
樂觀鎖和悲觀鎖的比較
- 樂觀鎖不是資料庫自己實現的，悲觀鎖是資料庫自己實現的
- 兩種鎖各有優缺點，不能認為一種好於另外一種，樂觀鎖適用於寫少的場景，也就是衝突發生很少的情況，這樣省了鎖的開銷，加大了系統的吞吐量。
- 但是如果經常發生衝突，上次應用不會retry，此時為了保證安全和維持效能，應該使用悲觀鎖
公平鎖
公平鎖。就是字面意思，公平的，是非搶佔式的，一個一個排好隊，等待執行，但是有缺點。如果某個執行緒執行的時間過長，會導致阻塞。比如ReentrantLock中的內部類 FairSync和ReentrantReadWriteLock中的內部類FairSync都是公平鎖
非公平鎖
非公平鎖，及時字面以自，搶佔式的，不管誰先來，誰後來，搶到了就是我的。比如ReentrantLock中的內部類 NonfairSync和ReentrantReadWriteLock中的內部類NonfairSync都是非公平鎖
顯示鎖和內建鎖
顯示鎖，是人為手動的鎖，如：ReentrantLock、Lock鎖，也就是說，實現了Lock的鎖都是顯示鎖
內建鎖：內建鎖使用synchronized，內建鎖是互斥鎖
Java中每個物件都可以用作一個實現同步的鎖。 執行緒進入同步程式碼塊或方法的時候會自動獲得該鎖，在退出同步程式碼塊或方法時會釋放該鎖。獲得內建鎖的唯一途徑就是進入這個鎖的保護的同步程式碼塊或方法。
輪詢鎖和定時鎖
由tryLock實現，與無條件獲取鎖模式相比，它們具有更完善的錯誤恢復機制。可避免死鎖的發生
boolean tryLock()：僅在呼叫時鎖為空閒狀態才獲取該鎖。如果鎖可用，則獲取鎖，並立即返回值 true。如果鎖不可用，則此方法將立即返回值 false。
tryLock的過載 tryLock(time,TimeUnit)就是定時鎖
物件鎖和類鎖
Java的物件鎖和類鎖，其實也就是 Java - 多執行緒 - 鎖和提升 第1篇開篇所說的8鎖 8鎖核心思想
- 關鍵字在實體方法上，鎖為當前範例
- 關鍵字在靜態方法上，鎖為當前Class物件
- 關鍵字在程式碼塊上，鎖為括號裡面的物件
1.物件鎖和類鎖在基本概念上和內建鎖是一致的，但是，兩個鎖是有很大的區別，物件鎖適用於物件的實體方法，或者一個物件範例上的，類鎖是作用於類的靜態方法或者一個類的class物件上的。
2.類的範例可以有多個，但是每個類只有一個class物件，不同範例的物件鎖是互不相干的，但是每個類只有一個類鎖。
3.其實類鎖只是一個概念上的東西，並不是真實存在的，它只是用來幫我們理解鎖定實體方法和靜態方法的區別。
4.synchronized只是一個內建的加鎖機制，當某個方法加上synchronized關鍵字的後，就表明要獲得該內建鎖才能執行，並不能阻止其他執行緒存取不需要獲得該鎖的方法。
5.呼叫物件的wait()方法的時候，會釋放持有的物件鎖，以便於呼叫 notify() 方法使用。notify()呼叫之後，會等到notify()所在的執行緒執行完畢之後再釋放鎖。
鎖粗化
就是將多次連線在一起的加鎖、解鎖操作合併為一次，將多個連續的鎖拓展為一個更大的鎖。
通常情況下，為了保證多執行緒間的有效並行，會要求每個執行緒持有鎖的時間儘可能短，但是大某些情況下，一個程式對同一個鎖不間斷、高頻地請求、同步與釋放，會消耗掉一定的系統資源，因為鎖的講求、同步與釋放本身會帶來效能損耗，這樣高頻的鎖請求就反而不利於系統效能的優化了，雖然單次同步操作的時間可能很短。鎖粗化就是告訴我們任何事情都有個度，有些情況下我們反而希望把很多次鎖的請求合併成一個請求，以降低短時間內大量鎖請求、同步、釋放帶來的效能損耗。
鎖消除
鎖消除即：刪除不必要的加鎖操作。根據程式碼逃逸技術，如果判斷到一段程式碼中，堆上的資料不會逃逸出當前執行緒。那麼可以認定這段程式碼是執行緒安全的，不必要加鎖。
鎖消除是發生在編譯器級別的一種鎖優化方式。有時候我們寫的程式碼完全不需要加鎖，卻執行了加鎖操作。
比如，StringBuffer類的append操作：
@Override
public synchronized StringBuffer append(String str) {
toStringCache = null;
super.append(str);
return this;
}
從原始碼中可以看出，append方法用了synchronized關鍵詞，它是執行緒安全的。但我們可能僅線上程內部把StringBuffer當作區域性變數使用：
public class Demo {
public static void main(String[] args) {
long start = System.currentTimeMillis();
int size = 10000;
for (int i = 0; i < size; i++) {
createStringBuffer("ic", "java");
}
long timeCost = System.currentTimeMillis() - start;
System.out.println("createStringBuffer:" + timeCost + " ms");
}
public static String createStringBuffer(String str1, String str2) {
StringBuffer sBuf = new StringBuffer();
// append方法是同步操作
sBuf.append(str1);
sBuf.append(str2);
return sBuf.toString();
}
}程式碼中createStringBuffer方法中的區域性物件sBuf，就只在該方法內的作用域有效，不同執行緒同時呼叫createStringBuffer()方法時，都會建立不同的sBuf物件，因此此時的append操作若是使用同步操作，就是白白浪費的系統資源。
這時我們可以通過編譯器將其優化，將鎖消除，前提是java必須執行在server模式（server模式會比client模式作更多的優化），同時必須開啟逃逸分析:
-server -XX:+DoEscapeAnalysis -XX:+EliminateLocks
其中+DoEscapeAnalysis表示開啟逃逸分析，+EliminateLocks表示鎖消除。
逃逸分析：比如上面的程式碼，它要看sBuf是否可能逃出它的作用域？如果將sBuf作為方法的返回值進行返回，那麼它在方法外部可能被當作一個全域性物件使用，就有可能發生執行緒安全問題，這時就可以說sBuf這個物件發生逃逸了，因而不應將append操作的鎖消除，但我們上面的程式碼沒有發生鎖逃逸，鎖消除就可以帶來一定的效能提升。
號誌
號誌有一個執行緒同步工具：Semaphore
下面我們來分析一下原始碼
public class Semaphore implements java.io.Serializable {
private static final long serialVersionUID = -3222578661600680210L;
// Sync鎖
private final Sync sync;
// Sync實現了AbstractQueueSynchronizer
abstract static class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = 1192457210091910933L;
// 初始化版本初始值
Sync(int permits) {
setState(permits);
}
// 獲取狀態
final int getPermits() {
return getState();
}
// 不公平嘗試共用
final int nonfairTryAcquireShared(int acquires) {
for (;;) {
int available = getState();
int remaining = available - acquires;
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
// 嘗試釋放共用
protected final boolean tryReleaseShared(int releases) {
for (;;) {
int current = getState();
int next = current + releases;
if (next < current) // overflow
throw new Error("Maximum permit count exceeded");
if (compareAndSetState(current, next))
return true;
}
}
// 減少狀態的指定值
final void reducePermits(int reductions) {
for (;;) {
int current = getState();
int next = current - reductions;
if (next > current) // underflow
throw new Error("Permit count underflow");
if (compareAndSetState(current, next))
return;
}
}
final int drainPermits() {
for (;;) {
int current = getState();
if (current == 0 || compareAndSetState(current, 0))
return current;
}
}
}
// 非公平鎖
static final class NonfairSync extends Sync {
private static final long serialVersionUID = -2694183684443567898L;
NonfairSync(int permits) {
super(permits);
}
protected int tryAcquireShared(int acquires) {
return nonfairTryAcquireShared(acquires);
}
}
// 公平鎖
static final class FairSync extends Sync {
private static final long serialVersionUID = 2014338818796000944L;
FairSync(int permits) {
super(permits);
}
protected int tryAcquireShared(int acquires) {
for (;;) {
if (hasQueuedPredecessors())
return -1;
int available = getState();
int remaining = available - acquires;
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
}
// 構造方法 設定初始版本號
public Semaphore(int permits) {
sync = new NonfairSync(permits);
}
// 構造方法
public Semaphore(int permits, boolean fair) {
sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}
// 增加1
public void acquire() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
// 不間斷地獲取
public void acquireUninterruptibly() {
sync.acquireShared(1);
}
// 從此號誌獲取許可，直到獲得一個許可為止，將一直阻塞
public void acquireUninterruptibly() {
sync.acquireShared(1);
}
// 僅在呼叫時可用時，才從此號誌獲取許可
public boolean tryAcquire() {
return sync.nonfairTryAcquireShared(1) >= 0;
}
// 定時設定
public boolean tryAcquire(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}
// 釋放
public void release() {
sync.releaseShared(1);
}
// 設定指定的個數
public void acquire(int permits) throws InterruptedException {
if (permits < 0) throw new IllegalArgumentException();
sync.acquireSharedInterruptibly(permits);
}
// 獲得許可證的給定數目從這個訊號，阻塞直到所有可用。
public void acquireUninterruptibly(int permits) {
if (permits < 0) throw new IllegalArgumentException();
sync.acquireShared(permits);
}
// 獲得許可證的給定數目從此號誌，只有在所有可在呼叫的時候。
public boolean tryAcquire(int permits) {
if (permits < 0) throw new IllegalArgumentException();
return sync.nonfairTryAcquireShared(permits) >= 0;
}
// 收購從此號誌許可證的給定數量，如果所有給定的等待時間內變得可用，並且當前執行緒未被中斷
public boolean tryAcquire(int permits, long timeout, TimeUnit unit)
throws InterruptedException {
if (permits < 0) throw new IllegalArgumentException();
return sync.tryAcquireSharedNanos(permits, unit.toNanos(timeout));
}
// 釋放
public void release(int permits) {
if (permits < 0) throw new IllegalArgumentException();
sync.releaseShared(permits);
}
// 返回現在的剩餘值
public int availablePermits() {
return sync.getPermits();
}
// 返回減少之後的值
public int drainPermits() {
return sync.drainPermits();
}
// 減少指定個數的值
protected void reducePermits(int reduction) {
if (reduction < 0) throw new IllegalArgumentException();
sync.reducePermits(reduction);
}
// 判斷是否時公平鎖
public boolean isFair() {
return sync instanceof FairSync;
}
// 判斷佇列是否有執行緒
public final boolean hasQueuedThreads() {
return sync.hasQueuedThreads();
}
// 返回執行緒的長度
public final int getQueueLength() {
return sync.getQueueLength();
}
// 返回佇列執行緒的集合
protected Collection<Thread> getQueuedThreads() {
return sync.getQueuedThreads();
}
// toString() 方法
public String toString() {
return super.toString() + "[Permits = " + sync.getPermits() + "]";
}
}
總結：
我們發現其本質還是 AbstractQueueSynchronizer 中的共用模式和獨佔模式
此類也有公平和非公平的實現
獨享鎖
獨享鎖，也叫獨佔鎖，意思是鎖A只能被一個鎖擁有，如synchronized，
ReentrantLock是獨享鎖，他是基於AQS實現的，在ReentrantLock原始碼中， 使用一個int型別的成員變數state來表示同步狀態，當state>0時表示已經獲取了鎖 。 而當c等於0的時候說明當前沒有執行緒佔有鎖，它提供了三個方法（getState()、setState(int newState)、compareAndSetState(int expect,int update)）來對同步狀態state進行操作，所以AQS可以確保對state的操作是安全的。
// 它預設是非公平鎖
public ReentrantLock() {
sync = new NonfairSync();
}
// 建立ReentrantLock，公平鎖or非公平鎖
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
// 而他會分別呼叫lock方法和unlock方法來釋放鎖
public void lock() {
sync.lock();
}
public void unlock() {
sync.release(1);
}
但是其實他不僅僅是會呼叫lock和unlock方法，因為我們的執行緒不可能一點問題沒有，如果說進入到了waiting狀態，在這個時候如果沒有unpark()方法，就沒有辦法來喚醒他， 所以，也就接踵而至出現了tryLock(),tryLock(long,TimeUnit)來做一些嘗試加鎖或者說是超時來滿足某些特定的場景的需求了
ReentrantLock會保證method-body在同一時間只有一個執行緒在執行這段程式碼，或者說，同一時刻只有一個執行緒的lock方法會返回。其餘執行緒會被掛起，直到獲取鎖。
從這裡我們就能看出，其實ReentrantLock實現的就是一個獨佔鎖的功能：有且只有一個執行緒獲取到鎖，其餘執行緒全部掛起，直到該擁有鎖的執行緒釋放鎖，被掛起的執行緒被喚醒重新開始競爭鎖。而在原始碼中通過AQS來獲取獨享鎖是通過呼叫acquire方法，其實這個方法是阻塞的
共用鎖
從我們之前的獨享所就能看得出來，獨享鎖是使用的一個狀態來進行鎖標記的，共用鎖其實也差不多，但是JAVA中有不想定力兩個狀態，所以區別出現了， 他們的鎖狀態時不一樣的。
基本的流程是一樣的，主要區別在於判斷鎖獲取的條件上，由於是共用鎖，也就允許多個執行緒同時獲取，所以同步狀態的數量同時的大於1的，如果同步狀態為非0，則執行緒就可以獲取鎖，只有當同步狀態為0時，才說明共用數量的鎖已經被全部獲取，其餘執行緒只能等待。
最典型的就是ReentrantReadWriteLock裡的讀鎖，它的讀鎖是可以被共用的，但是它的寫鎖確每次只能被獨佔。
總結
- 獨享鎖：同時只能有一個執行緒獲得鎖。
- 共用鎖：可以有多個執行緒同時獲得鎖。
分段鎖
在JDK1.7之前，HashMap的底層是陣列+連結串列。同樣的，ConcurrentHashMap的底層樹結構是陣列+連結串列，但是和HashMap不一樣的是，ConcurrentHashMap的中存放資料是一段一段的。即由很多個Segment(段)組成的，每個Segment中都有著類似於陣列+連結串列的結構
關於Segment
1.ConcurrentHashMap由三個引數
- initalCapacity：初始化總容量，預設值為16
- loadFactor：載入因子，預設0.75
- concurrentLevel：並行級別，預設16
2.其中的並行級別控制了Segment的個數。在y一個ConcurrentHashMap建立後Segment的個數是不能變的，擴容過程是改變每個Segment的大小
關於分段鎖
Segment繼承了重入鎖ReentrantLock，有了鎖的的功能。每個鎖控制的是一段，當每個Segment越來越大的時候，鎖的粒度就越來越大了
- 分段鎖的優勢是保證造操作不同段map的時候進行鎖的競爭和等待。這相當於直接對整個map同步synchronized只是有優勢的
- 缺點在於分成很多段的時候會浪費很多的記憶體空間（不連續，碎片化），操作map的時候競爭一個分段鎖概率狠小的時候，分段鎖反而會造成更新等操作的長時間等待，分段鎖的效能會下降
JDK1.8的map實現
JDK中的HashMap和ConcurrentHashMap。底層資料結構為陣列+連結串列+紅黑樹。陣列可以擴容，連結串列可以轉化為紅黑樹（本篇文章不對紅黑樹做講解，之前已經分析過）
新版的ConcurrentHashMap為什麼不使用ReentrantLock而使用synchronized?
減少記憶體開銷：如果使用ReenteantLock則需要節點繼承AQS來獲得同步支援，增加記憶體開銷，而1.8中只有頭節點需要同步
內部優化：synchronized是JVM直接支援的，JVM能在執行時做出相應的優化措施：鎖粗化、鎖消除、鎖自旋等
鎖的粒度
首先鎖的粒度並沒有變粗，甚至變得更細了。每當擴容一次，ConcurrentHashMap的並行度就擴大一倍。
Hash衝突
JDK1.7中，ConcurrentHashMap從過二次hash的方式（Segment -> HashEntry）能夠快速的找到查詢的元素。在1.8中通過連結串列加紅黑樹的形式彌補了put、get時的效能差距。
擴容
JDK1.8中，在ConcurrentHashmap進行擴容時，其他執行緒可以通過檢測陣列中的節點決定是否對這條連結串列（紅黑樹）進行擴容，減小了擴容的粒度，提高了擴容的效率。
死鎖案例和排查
public class DeadLockDemo {
public static void main(String[] args) {
String lockA = "lockA";
String lockB = "lockB";
MyThread myThread1 = new MyThread(lockA,lockB);
MyThread myThread2 = new MyThread(lockB,lockA);
new Thread(myThread1).start();
new Thread(myThread2).start();
}
}
class MyThread implements Runnable {
private String lockA;
private String lockB;
public MyThread(String lockA, String lockB) {
this.lockA = lockA;
this.lockB = lockB;
}
@Override
public void run() {
synchronized (lockA) {
System.out.println(Thread.currentThread().getName() + "lock：" + lockA + " => " + lockB);
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lockB) {
System.out.println(Thread.currentThread().getName() + "lock：" + lockB + " => " + lockA);
}
}
}
}
到此這篇關於Java多執行緒之鎖學習(增強版)的文章就介紹到這了,更多相關Java多執行緒 鎖內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！
相關文章
-
黑科技的輕簡出行，告別「電量焦慮症」：Anker氮化鎵超能充系列
综合看Anker超能充系列的性价比很高，并且与不仅和iPhone12/苹果<em>Mac</em>Book很配，而且适合多设备充电需求的日常使用或差旅场景，不管是安卓还是Switch同样也能用得上它，希望这次分享能给准备购入充电器的小伙伴们有所
2021-06-01 09:31:42
-
吳亦凡廠牌首秀，L4WUDU居然忘詞了，Rapper和明星比還是有差距！
除了L4WUDU与吴亦凡已经多次共事，成为了明面上的厂牌成员，吴亦凡还曾带领20XXCLUB全队参加2020年的一场音乐节，这也是20XXCLUB首次全员合照，王嗣尧Turbo、陈彦希Regi、<em>Mac</em> Ova Seas、林渝植等人全部出场。然而让
2021-06-01 09:31:34
-
IPFS、Chia、Bzz和ICP挖礦該怎麼選？哪一個更有優勢？
目前应用IPFS的机构：1 谷歌<em>浏览器</em>支持IPFS分布式协议 2 万维网 (历史档案博物馆)数据库 3 火狐<em>浏览器</em>支持 IPFS分布式协议 4 EOS 等数字货币数据存储 5 美国国会图书馆，历史资料永久保存在 IPFS 6 加
2021-06-01 09:31:24
-
有哪些事是買了雪佛蘭後才知道的？美事偷著樂，開拓者車主隨聊
开拓者的车机是兼容苹果和<em>安卓</em>，虽然我不怎么用，但确实兼顾了我家人的很多需求：副驾的门板还配有解锁开关，有的时候老婆开车，下车的时候偶尔会忘记解锁，我在副驾驶可以自己开门：第二排设计很好，不仅配置了一个很大的
2021-06-01 09:30:48
-
iPhone12在618最新定價，跌價幅度超過1400元，還等iPhone13嗎？
不仅是<em>安卓</em>手机，苹果手机的降价力度也是前所未有了，iPhone12也“跳水价”了，发布价是6799元，如今已经跌至5308元，降价幅度超过1400元，最新定价确认了。iPhone12是苹果首款5G手机，同时也是全球首款5nm芯片的智能机，它
2021-06-01 09:30:45