圖解AQS的設計與實現,手摸手帶你實現一把互斥鎖!
AQS是併發程式設計中非常重要的概念,它是juc包下的許多併發工具類,如CountdownLatch,CyclicBarrier,Semaphore 和鎖, 如ReentrantLock, ReaderWriterLock的實現基礎,提供了一個基於int狀態碼和佇列來實現的併發框架。本文將對AQS框架的幾個重要組成進行簡要介紹,讀完本文你將get到以下幾個點:
- AQS進行併發控制的機制是什麼
- 共享模式和獨佔模式獲取和釋放同步狀態的詳細過程
- 基於AQS框架實現一個簡易的互斥鎖
一,AQS基本概念
AQS(AbstractQueuedSynchronizer)是用來構建鎖或者其他同步元件的基礎框架,它使用了一個int成員變數來表示狀態,通過內建的FIFO(first in,first out)佇列來完成資源獲取執行緒的排隊工作。
1.1 同步狀態
AQS中維持一個全域性的int狀態碼(state),執行緒通過修改(加/減指定的數量)碼是否成功來決定當前執行緒是否成功獲取到同步狀態。
1.1 獨佔or共享模式
AQS支援兩種獲取同步狀態的模式既獨佔式和共享式。顧名思義,獨佔式模式同一時刻只允許一個執行緒獲取同步狀態,而共享模式則允許多個執行緒同時獲取。
1.2 同步佇列
同步佇列(一個FIFO雙向佇列)是AQS的核心,用來完成同步狀態的管理,當執行緒獲取同步狀態失敗時,AQS會將當前執行緒以及等待狀態等資訊構造成一個節點並加入到同步佇列,同時會阻塞當前執行緒。
二,獨佔模式獲取與釋放狀態
獨佔模式既同一時間只能由一個執行緒持有同步狀態。當多個執行緒競爭時(acquire),獲取到同步狀態的執行緒會將當前執行緒賦值給Thread exclusiveOwnerThread
2.1 獲取同步狀態
/** * 獲取同步狀態 */ public final void acquire(int arg) { /** * 1. tryAcquire 嘗試獲取同步狀態; * 2.1 addWaiter 如果嘗試獲取到同步狀態失敗,則加入到同步佇列中; * 2.2 acquireQueued 在佇列中嘗試獲取同步狀態. */ if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterrupt(); }
多執行緒併發獲取(修改)同步狀態, 修改同步狀態成功的執行緒標記為擁有同步狀態
/** * 嘗試獲取同步狀態【子類中實現】,因為aqs基於模板模式,僅提供基於狀態和同步佇列的實 * 現框架,具體的實現邏輯由子類決定 */ protected final boolean tryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); if (c == 0) { // a. 嘗試修改狀態值操作執行成功 if (!hasQueuedPredecessors() && compareAndSetState(0, acquires)) { // b. 修改狀態值成功,記錄當前持有同步狀態的執行緒資訊 setExclusiveOwnerThread(current); return true; } // 如果當前執行緒已經持有同步狀態,繼續修改同步狀態【重入鎖實現原理,不理解可以先忽略】 } else if (current == getExclusiveOwnerThread()) { int nextc = c + acquires; if (nextc < 0) throw new Error("Maximum lock count exceeded"); setState(nextc); return true; } return false; }
獲取失敗的執行緒,加入到同步佇列的隊尾;加入到佇列中後,如果當前節點的前驅節點為頭節點再次嘗試獲取同步狀態(下文程式碼:p == head && tryAcquire(arg))。
/** * 沒有獲取到同步狀態的執行緒加入到隊尾部 */ private Node addWaiter(Node mode) { Node node = new Node(Thread.currentThread(), mode); // 嘗試用最快的方式入隊,如果入隊失敗,再走完整的入隊方法 Node pred = tail; if (pred != null) { node.prev = pred; // 將當前執行緒設定到隊尾 if (compareAndSetTail(pred, node)) { pred.next = node; return node; } } // 正常的入隊方法 enq(node); return node; } /** * 同步佇列中節點,嘗試獲取同步狀態 */ final boolean acquireQueued(final Node node, int arg) { boolean failed = true; try { boolean interrupted = false; // 自旋(死迴圈) for (;;) { // 只有當前節點的前驅節點是頭節點時才會嘗試執行獲取同步狀態操作 final Node p = node.predecessor(); if (p == head && tryAcquire(arg)) { setHead(node);// 注意: 此處重點, 當前節點設定為頭節點,相當於頭節點出隊 p.next = null; // help GC failed = false; return interrupted; } // 獲取失敗後是否進入wait if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) interrupted = true; } } finally { if (failed) cancelAcquire(node); } }
- 如果頭節點的下一個節點嘗試獲取同步狀態失敗後,會進入等待狀態;其他節點則繼續自旋。
// 虛擬碼
final boolean acquireQueued(final Node node, int arg) {
for (;;) {
// -------獲取同步狀態失敗-------
// 獲取失敗後是否進入wait
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
}
/**
* 當獲取同步狀態失敗後是否進入park狀態
*/
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
// 前驅節點為喚醒狀態,返回true【後面程式碼暫時可以忽略】
if (ws == Node.SIGNAL)
return true;
if (ws > 0) {
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
獨佔模式獲取同步狀態總結
2.2 釋放同步狀態
當執行緒執行完相應邏輯後,需要釋放同步狀態,使後繼節點有機會同步狀態(讓出資源,讓排隊的執行緒使用)。這時就需要呼叫release(int arg)方法。呼叫該方法後,會喚醒後繼節點。
- 釋放同步狀態,喚醒後繼節點
/**
* 釋放同步狀態
*/
public final boolean release(int arg) {
// 1. 嘗試釋放同步狀態
if (tryRelease(arg)) {
Node h = head;
// 釋放成功後,執行unpark,既喚醒操作(暫時可忽略waitStatus,涉及到條件佇列)
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
/**
* 嘗試釋放同步狀態,既將同步狀態減去指定的值
* 如果state = 0,表示當前執行緒 獲取次數 = 釋放次數,既釋放成功,此時將持有同步狀態執行緒標誌為null
*/
protected final boolean tryRelease(int releases) {
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
// 狀態碼=0,表示釋放成功了
if (c == 0) {
free = true;
// 獨佔標誌設定為null
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
/**
* 喚醒後繼節點操作
*/
private void unparkSuccessor(Node node) {
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
// 獲取後繼節點
Node s = node.next;
if (s == null || s.waitStatus > 0) {
s = null;
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
// 喚醒後繼節點
if (s != null)
LockSupport.unpark(s.thread);
}
後繼節點獲取同步狀態成功,頭節點出隊。需要注意的事,出隊操作是間接的,有節點獲取到同步狀態時,會將當前節點設定為head,而原本的head設定為null。
/**
* 同步佇列中節點,嘗試獲取同步狀態(虛擬碼)
* 獲取成功後,當前節點設定為頭節點,頭節點設定為null,既頭節點出隊
*/
final boolean acquireQueued(final Node node, int arg) {
try {
// 自旋(死迴圈)
for (;;) {
if (p == head && tryAcquire(arg)) {
// a. 操作:當前節點設定為頭節點,當前節點的前驅節點設定為null
setHead(node);
// b. 原始的head的next設定為null,此時原始的head已經被移出佇列
p.next = null; // help GC
failed = false;
return interrupted;
}
}
}
}
/**
* a.當前節點設定為頭節點,當前節點的前驅節點設定為null
*/
private void setHead(Node node) {
head = node;
node.thread = null;
node.prev = null;
}
2.3 其他競爭情況
當同步佇列中頭節點喚醒後繼節點時,此時可能有其他執行緒嘗試獲取同步狀態。
假設獲取成功,將會被設定為頭節點。
頭節點後續節點獲取同步狀態失敗。
三,共享模式獲取與釋放狀態
共享模式和獨佔模式最主要的區別是在支援同一時刻有多個執行緒同時獲取同步狀態。為了避免帶來額外的負擔,在上文中提到的同步佇列中都是用獨佔模式進行講述,其實同步佇列中的節點應該是獨佔和共享節點並存的。
接下來將針對共享模式狀態下獲取與釋放狀態的過程,圖文並茂得進行分析。
3.1 獲取同步狀態
首先至少要呼叫一次tryAcquireShared(arg)方法,如果返回值大於等於0表示獲取成功。
當獲取鎖失敗時,則建立一個共享型別的節點並進入一個同步佇列,然後進入佇列中進入自旋狀態(阻塞,喚醒兩種狀態來回切換,直到獲取到同步狀態為止)
當佇列中的等待執行緒被喚醒以後就重新嘗試獲取鎖資源,如果成功則喚醒後面還在等待的共享節點並把該喚醒事件傳遞下去,即會依次喚醒在該節點後面的所有共享節點,否則繼續掛起等待。
當一個同享節點獲取到同步狀態,並喚醒後面等待的共享狀態的結果如下圖所示:
/**
* 共享模式獲取同步狀態;
* 1. 首先至少要呼叫一次tryAcquireShared(arg)方法,如果返回值大於等於0表示獲取成功,直接返回結果即可
* 2. 否則,將會加入到同步佇列中,反覆阻塞與喚醒,直到獲取同步狀態成功為止; 獲取成功後會喚醒後面還在等待的共享節點並把該喚醒事件傳遞下去,即會依次喚醒在該節點後面的所有共享節點
*/
public final void acquireShared(int arg) {
if (tryAcquireShared(arg) < 0)
doAcquireShared(arg);
}
/**
* 2. 自旋模式獲取同步狀態
*/
private void doAcquireShared(int arg) {
// 2.1 第一次獲取失敗後,會將此執行緒加入到同步佇列中
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
// 如果前驅節點是頭節點,嘗試獲取同步狀態
final Node p = node.predecessor();
if (p == head) {
// r > 0表示獲取同步狀態成功,並且還有共享型別節點在同步佇列中
// r == 0 表示獲取同步狀態成功,同步佇列中沒有其他共享模式節點
int r = tryAcquireShared(arg);
if (r >= 0) {
// !!!! 獲取同步狀態成功後,將當前node設定為頭節點,並向後傳播,喚醒共享模式等待的節點
setHeadAndPropagate(node, r);
p.next = null; // help GC
if (interrupted)
selfInterrupt();
failed = false;
return;
}
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
/**
* 設定新的頭結點,並設定後面需要喚醒的節點
*/
private void setHeadAndPropagate(Node node, int propagate) {
Node h = head; // Record old head for check below
setHead(node);
// propagate > 0 表明後面需要喚醒的共享模式節點
if (propagate > 0 || h == null || h.waitStatus < 0 ||
(h = head) == null || h.waitStatus < 0) {
Node s = node.next;
// 如果當前節點的後繼節點是共享型別或者沒有後繼節點,則進行喚醒
// 這裡可以理解為除非明確指明不需要喚醒(後繼等待節點是獨佔型別),否則都要喚醒
if (s == null || s.isShared())
doReleaseShared();
}
}
/**
* 喚醒所有共享模式節點
*/
private void doReleaseShared() {
for (;;) {
// 喚醒操作由頭結點開始,注意這裡的頭節點已經是上面新設定的頭結點了
// 其實就是喚醒上面新獲取到共享鎖的節點的後繼節點
Node h = head;
if (h != null && h != tail) {
int ws = h.waitStatus;
// 表示後繼節點需要被喚醒
if (ws == Node.SIGNAL) {
//這裡需要控制併發,因為入口有setHeadAndPropagate跟release兩個,避免兩次unpark
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
continue;
//執行喚醒操作
unparkSuccessor(h);
}
//如果後繼節點暫時不需要喚醒,則把當前節點狀態設定為PROPAGATE確保以後可以傳遞下去
else if (ws == 0 &&
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue;
}
// 如果頭結點沒有發生變化,表示設定完成,退出迴圈
// 如果頭結點發生變化,比如說其他執行緒獲取到了鎖,為了使自己的喚醒動作可以傳遞,必須進行重試
if (h == head)
break;
}
}
最後,獲取到同步狀態的執行緒執行完畢,同步佇列中只有一個獨佔節點:
3.2 釋放同步狀態
釋放同步狀態後,同步佇列的變化過程和共享節點獲取到同步狀態後的變化過程一致,此處不再進行贅述。
/**
* 釋放同步狀態,如果釋放成功,喚醒後面等待的節點
*
*/
public final boolean releaseShared(int arg) {
// 1. 嘗試釋放同步狀態
if (tryReleaseShared(arg)) {
// 2. 釋放成功後,喚醒後續等待共享節點
doReleaseShared();
return true;
}
return false;
}
四,基於AQS實現互斥鎖
讀到此處,大部分人應該還比較懵逼,似懂非懂。接下來筆者將通過AQS實現一個互斥鎖帶你開啟AQS的正確開啟姿勢。
多執行緒環境count += 1可能會存在問題,詳情可以看在併發程式設計bug的來源中介紹的三大原因。正如大多數人都知道的,我們通常可以使用synchronized關鍵字進行同步,接下來我們就基於AQS自定義一個互斥鎖來完成相同的功能。
4.1 程式碼實現
/**
* 自定義互斥鎖
*
* @author cruder
* @time 2019/11/29 23:23
*/
public class MutexLock {
private static final Sync STATE_HOLDER = new Sync();
/**
* 通過Sync內部類來持有同步狀態, 當狀態為1表示鎖被持有,0表示鎖處於空閒狀態
*/
private static class Sync extends AbstractQueuedSynchronizer {
/**
* 是否被獨佔, 有兩種表示方式
* 1. 可以根據狀態,state=1表示鎖被佔用,0表示空閒
* 2. 可以根據當前獨佔鎖的執行緒來判斷,即getExclusiveOwnerThread()!=null 表示被獨佔
*/
@Override
protected boolean isHeldExclusively() {
return getExclusiveOwnerThread() != null;
}
/**
* 嘗試獲取鎖,將狀態從0修改為1,操作成功則將當前執行緒設定為當前獨佔鎖的執行緒
*/
@Override
protected boolean tryAcquire(int arg) {
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
/**
* 釋放鎖,將狀態修改為0
*/
@Override
protected boolean tryRelease(int arg) {
if (getState() == 0) {
throw new UnsupportedOperationException();
}
setExclusiveOwnerThread(null);
setState(0);
return true;
}
}
/**
* 下面的實現Lock介面需要重寫的方法,基本是就是呼叫內部內Sync的方法
*/
public void lock() {
STATE_HOLDER.acquire(1);
}
public void unlock() {
STATE_HOLDER.release(1);
}
}
4.2 鎖的測試
我們定義一個計數器類,裡面定義了2個不同的計數方法,其中一個使用互斥鎖進行同步。開啟10個執行緒併發執行,每個執行緒計數10000次,然後對比統計結果與預期的100,000是否相符。
package myLock;
import java.util.concurrent.*;
/**
* 自定義鎖測試
*
* @author liqiang
* @time 2019/11/29 12:39
*/
public class MyLockTest {
public static void main(String[] args) throws InterruptedException {
int threadNum = 10;
int countPerThread = 10000;
// 執行緒池建立的正確姿勢
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(threadNum, threadNum, 1000, TimeUnit.SECONDS, new ArrayBlockingQueue<>(10), new ThreadPoolExecutor.AbortPolicy());
CountDownLatch countDownLatch = new CountDownLatch(threadNum);
Counter counter = new Counter();
Counter counterUnsafe = new Counter();
for (int i = 0; i < threadNum; i++) {
threadPool.submit(() -> {
for (int j = 0; j < countPerThread; j++) {
counter.getAndIncrement();
counterUnsafe.getAndIncrementUnSfae();
}
countDownLatch.countDown();
});
}
countDownLatch.await();
System.out.printf("%s 個執行緒,每個執行緒累加了 %s 次,執行結果:safeCounter = %s, unsafeCounter = %s ", threadNum, countPerThread, counter.get(), counterUnsafe.get());
threadPool.shutdownNow();
}
}
class Counter {
private MutexLock mutexLock;
private volatile int count;
Counter() {
this.mutexLock = new MutexLock();
}
int get() {
return count;
}
int getAndIncrement() {
mutexLock.lock();
count++;
mutexLock.unlock();
return count;
}
int getAndIncrementUnSfae() {
count++;
return count;
}
}
結果和預期一樣,用自定義鎖實現的計數器統計沒有誤差。
五,總結
- AQS通過一個int同步狀態碼,和一個(先進先出)佇列來控制多個執行緒訪問資源
- 支援獨佔和共享兩種模式獲取同步狀態碼
- 當執行緒獲取同步狀態失敗會被加入到同步佇列中
- 當執行緒釋放同步狀態,會喚醒後繼節點來獲取同步狀態
- 共享模式下的節點獲取到同步狀態或者釋放同步狀態時,不僅會喚醒後繼節點,還會向後傳播,喚醒所有同步節點
- 使用volatile關鍵字保證狀態碼線上程間的可見性,CAS操作保證修改狀態碼過程的原子性。
AQS的設計與實現比本文中描述的要稍微複雜一些,為了達到快速入門的效果所以本文進行了簡化。對於沒有講到的內容,比如,對於獨佔模式下超時獲取同步狀態, 佇列中節點狀態的流轉, 條件佇列等沒有講到的內容,將會放到下一篇文章中進行介紹。
六,Q&A
Question1: 在java中通常使用synchronized來實現方法同步,AQS中通過CAS保證了修改同步狀態的一致性問題,那麼對比synchronized,cas有什麼優勢不同與優勢呢?你還知道其他無鎖併發的策略嗎?
我的相關文章:
一文搞懂併發程式設計bug的來源
無鎖併發的CAS為何如此優秀
參考:
https://www.jianshu.com/p/1161d33fc1d0
《Java併發程式設計的藝術》
《Java併發程式設計實戰》
相關推薦
圖解AQS的設計與實現,手摸手帶你實現一把互斥鎖!
AQS是併發程式設計中非常重要的概念,它是juc包下的許多併發工具類,如CountdownLatch,CyclicBarrier,Semaphore 和鎖, 如ReentrantLock, ReaderWriterLock的實現基礎,提供了一個基於int狀態碼和佇列來實現的併發框架。本文將對AQS框架的幾個重
又長又細,萬字長文帶你解讀Redisson分散式鎖的原始碼
前言 上一篇文章寫了Redis分散式鎖的原理和缺陷,覺得有些不過癮,只是簡單的介紹了下Redisson這個框架,具體的原理什麼的還沒說過呢。趁年前專案忙的差不多了,反正閒著也是閒著,不如把Redisson的原始碼也學習一遍好了。 雖說是一時興起,但仔細研究之後發現Redisson的原始碼解讀工作量還是挺大
手摸手,帶你實現程式碼自動部署
為什麼? 為什麼要實現自動部署? 在2個月的時間裡,一直都在忙著整理部落格,每一個程式設計師都有一個部落格夢(當然也不排除有些是沒有的),我先後使用過各種部落格系統: vuepress react-static jekyll hexo ... 這些都因為前前後後的原因,
手摸手,帶你用vue實現後臺管理許可權系統及頂欄三級選單顯示
手摸手,帶你用vue實現後臺管理許可權系統及頂欄三級選單顯示 效果演示地址 專案demo展示 重要功能總結 許可權功能的實現 許可權路由思路: 根據使用者登入的roles資訊與路由中配置的roles資訊進行比較過濾,生成可以訪問的路由表,並通過router.addRoutes(store.gett
淺談Java中的Condition條件佇列,手摸手帶你實現一個阻塞佇列!
條件佇列是什麼?可能很多人和我一樣答不出來,不過今天終於搞清楚了! 什麼是條件佇列 條件佇列:當某個執行緒呼叫了wait方法,或者通過Condition物件呼叫了await相關方法,執行緒就會進入阻塞狀態,並加入到對應條件佇列中。 在等待喚醒機制相關文章中我們提到了條件佇列,即當物件獲取到同步鎖之後,如果呼叫
【手摸手,帶你搭建前後端分離商城系統】03 整合Spring Security token 實現方案,完成主業務登入
## 【手摸手,帶你搭建前後端分離商城系統】03 整合Spring Security token 實現方案,完成主業務登入 上節裡面,我們已經將基本的前端 `VUE + Element UI` 整合到了一起。並且通過 `axios` 傳送請求到後端API。 解決跨域問題後、成功從後端獲取到資料。 本小結
【轉】手摸手,帶你用vue擼後臺 系列二(登錄權限篇)
userinfo ogr abort 變化 再次 狀態碼 quest -o 監聽 前言 拖更有點嚴重,過了半個月才寫了第二篇教程。無奈自己是一個業務猿,每天被我司的產品虐的死去活來,之前又病了一下休息了幾天,大家見諒。 進入正題,做後臺項目區別於做其它的項目,權限驗證與
手摸手教你自己動手實現一個前端路由
前言 用過現代前端框架的同學,對前端路由一定不陌生, vue, react, angular 都有自己的 router, 那麼你對 router 的工作原理了解嗎? 如果還不瞭解, 那麼請跟我一起來手寫一個簡單的前端路由, 順便了解一下. 實現路由的2種方式 hash模式
ArcEngine10.2設計與開發課程學習(作業四)——實現地圖的簡單渲染和唯一值渲染
所有習題材料:連結:HTTPS://pan.baidu.com/s/1oiylGi6IEgndYO2j9_oQnQ 提取碼:jp3r 複製這段內容後開啟百度網盤手機應用程式,操作更方便哦 本題EXE:連結:HTTPS://pan.baidu.com/s/10_buC4K1
手摸手帶你部署git伺服器實現自動釋出程式碼
前段趁著活動買了個騰訊雲伺服器,一直沒抽時間去折騰,最近才開始部署了一個自己專屬的git倉庫,實現程式碼自動釋出部署功能。(我也想成為努力向上,積極進取的有志青年啊!)文章的內容基本都是參考自谷歌搜尋,然後按我的思路重新整理一遍,既是為了分享也是為了鞏固知識。 我也是第一次折騰伺服器,前期部署就
手摸手,帶你用vue擼後臺 系列二(登入許可權篇)
前言 拖更有點嚴重,過了半個月才寫了第二篇教程。無奈自己是一個業務猿,每天被我司的產品虐的死去活來,之前又病了一下休息了幾天,大家見諒。 進入正題,做後臺專案區別於做其它的專案,許可權驗證與安全性是非常重要的,可以說是一個後臺專案一開始就必須考慮和搭建的基礎核心功能
關於單點登入原理與簡單實現,寫的太好了一看就懂!
一、單系統登入機制1、http無狀態協議web應用採用browser/server架構,http
手摸手,帶你用合理的姿勢使用 webpack 4(上)
(點選上方公眾號,可快速關注)作者:華爾街見聞技術團隊 - 花褲衩segmentfault.co
根據vue-cli手摸手實現一個自己的腳手架
故事背景 身為一個入門前端七個月的小菜雞,在我入門前端的第一天就接觸到了vue,並且死皮賴臉的跟他打了這麼久的交到,還記得第一次用vue init webpack 這句命令一下生成一個模板的時候那種心情,當時我就想,要是自己也能寫一個的話,那會是灰常吃雞的吧 o( ̄▽ ̄)ブ,所以說今天我們也要簡單實現一個自
基於七牛雲物件儲存,搭建一個自己專屬的極簡Web圖床應用(手摸手的註釋講解核心部分的實現原理)
一個極簡的Web圖床應用,支援複製貼上與拖拽上傳圖片 1.開發緣由 日常使用Vs Code編寫markdown筆記與部落格文章時,在文章中插入圖片時發現非常不便 使用本地檔案編寫相對路徑---沒法直接複製貼上到其它地方 使用第三方的圖床---需要登入賬號(還是放到自己"口袋"裡放心) vs code內建外掛
YApi——手摸手,帶你在Win10環境下安裝YApi視覺化介面管理平臺
手摸手,帶你在Win10環境下安裝YApi視覺化介面管理平臺 YApi YApi 是高效、易用、功能強大的 api 管理平臺,旨在為開發、產品、測試人員提供更優雅的介面管理服務。可以幫助開發者輕鬆建立、釋出、維護 API,YApi 還為使用者提供了優秀的互
【手摸手,帶你搭建前後端分離商城系統】01 搭建基本程式碼框架、生成一個基本API
## 【手摸手,帶你搭建前後端分離商城系統】01 搭建基本程式碼框架、生成一個基本API 通過本教程的學習,將帶你從零搭建一個商城系統。 當然,這個商城涵蓋了很多流行的`知識點`和`技術核心` ### 我可以學習到什麼? - SpringBoot - 鑑權與認證、token、有關許可權的相關的內容
【手摸手,帶你搭建前後端分離商城系統】02 VUE-CLI 腳手架生成基本專案,axios配置請求、解決跨域問題
## 【手摸手,帶你搭建前後端分離商城系統】02 VUE-CLI 腳手架生成基本專案,axios配置請求、解決跨域問題。 回顧一下上一節我們學習到的內容。已經將一個 `usm_admin 後臺使用者` 表的基本增刪改查全部都完成了。並且通過`swagger` 測試了我們的介面資訊,並且順利通過測試。本節將通
Python裏面幾種排序算法的比較,sorted的底層實現,雖然我們知道sorted的實現方式,但是
增長 歸並排序 sha __main__ 代碼 復雜 位置 好的 strong 算法與數據結構基礎 原文鏈接:http://note.youdao.com/noteshare?id=7b9757930ce3cc9e0a5e61e4d0aa9ea2&sub=2726FFA02
關於 MongoDB 與 SQL Server 通過本身自帶工具實現數據快速遷移 及 註意事項 的探究
數據遷移工具 文件中 文件導入 原本 修改字段 信息 字符 變化 是否 背景介紹 隨著業務的發展、需求的變化,促使我們追求使用不同類型的數據庫,充分發揮其各自特性。如果決定采用新類型的數據庫,就需要將既有的數據遷移到新的數據庫中。在這類需求中,將SQL Server中的數據