java高并發總結-常用于面試複習

定義：

獨占鎖是一種悲觀保守的加鎖政策，它避免了讀/讀沖突，如果某個隻讀線程擷取鎖，則其他讀線程都隻能等待，這種情況下就限制了不必要的并發性，因為讀操作并不會影響資料的一緻性。

共享鎖則是一種樂觀鎖，它放寬了加鎖政策，允許多個執行讀操作的線程同時通路共享資源。

分類：

獨占鎖： ReentrantLock， ReentrantReadWriteLock.WriteLock

共享鎖：ReentrantReadWriteLock.ReadLock，CyclicBarrier， CountDownLatch和Semaphore都是共享鎖

其他：

wait(), notify() @hxx，對應Contition的 await 和 signal

前者是object，在代碼中用鎖對象即可調用，後者是一個即可，必須使用ReentrantLock生成

final Lock lock = new ReentrantLock();

final Condition notFull = lock.newCondition();

final Condition notEmpty = lock.newCondition();

Synchronized

ReentrantLock是Synchronized一種更進階的改進

1： 更加面向對象，性能更好

2： 提供了更多機制，比如時間鎖等候，可中斷鎖等候，鎖投票等

3： ReentrantLock提供了可輪詢的鎖請求，提供tryLock()方法；而synchronized則會一直阻塞等待

Lock lock = ...;

if (lock.tryLock()) {

try {

// manipulate protected state

} finally {

lock.unlock();

}

} else {

// 資源正在被别人寫，先做别的事情吧，比如說列印一行日志

注意事項：

除了Synchronized自動走出鎖範圍，其餘占有了鎖，一定要記得釋放鎖，可以在finally中釋放!!!!

公平參數，預設都是關閉的，是以不要以為等的時間越長就能更大幾率獲得鎖！公平和非公平對應着：公平鎖和非公平鎖（Sync類的兩個子類），非公平鎖無視等待隊列，直接上來就是搶！

java實作鎖的底層都是使用Sync類，private final Sync sync;  

是繼承了AbstractQueuedSynchronizer的内部抽象類，主要由它負責實作鎖的功能。關于 AbstractQueuedSynchronizer 隻要知道它内部存在一個擷取鎖的等待隊列及其互斥鎖狀态下的int狀态位（0目前沒有線程持有該鎖、n存在某線程重入鎖n次）即可，該狀态位也可用于其它諸如共享鎖、信号量等功能。

----------------------------------------

Demo code：

1: CountDownLatch

用于n個線程等待其餘M個線程結束, 類位于java.util.concurrent包下

代碼：

CountDownLatch doneSignal = new CountDownLatch(3); // 定義了計數器為3.表示有3個線程結束即可！

for(int i=0; i<5; i++)

new InnerThread().start(); // m個線程，InnerThread的run方法末尾中寫了doneSignal .countDown(); 必須手動減

doneSignal.await(); // 阻塞，直到3個線程結束

//  await(long timeout, TimeUnit unit) throws InterruptedException { }; 這個就可以實作逾時功能

2: CyclicBarrier

java.util.concurrent包，實作 M 個線程在barrier栅欄處互相等待，可以重用狀态（是以叫cycli），1的計數器隻能減不能重新指派！

CyclicBarrier barrier = new CyclicBarrier(N);// N個線程互相等

for(int i=0;i<N;i++)

new Writer(barrier).start(); // Writer的run方法需要M個線程一起完成的點中寫了barrier.await();

3： Semaphore

java.util.concurrent包，用于限制最多M個線程同時并發

int N = 8; //勞工數

Semaphore semaphore = new Semaphore(5); //機器數目， 限制了最多5個并發， 預設是不公平的構造可以加true

new Worker(i,semaphore).start();

@Override

public void run() {

semaphore.acquire(); // 拿憑證，總共5張憑證，沒拿到會阻塞， 不想阻塞可用tryAcquire

System.out.println("勞工"+this.num+"占用一個機器在生産...");

Thread.sleep(2000);

System.out.println("勞工"+this.num+"釋放出機器");

semaphore.release(); // 釋放憑證

} catch (InterruptedException e) {

e.printStackTrace();

4： ReentrantLock

java.util.concurrent包，用于實作同步功能，與synchronized相似但是面向對象更靈活

ReentrantLock takeLock = new ReentrantLock();

// 擷取鎖

takeLock.lock();

// 業務邏輯

// 釋放鎖

takeLock.unlock();

5： ReentrantReadWriteLock

4是其父類，根據名字可以看到這個類區分了讀寫鎖，與4的優勢是線程大多在資料結構中讀取資料而少有修改時這個就有用了。

讀寫鎖要實作的功能是三點： 多個讀互相不幹擾；多個寫操作必須獨占鎖；讀和寫操作要上鎖！（@hxx第一個分号我我為什麼要用黑色，因為這就是讀寫鎖出現的意義，提升了讀的性能，不然就用4了）

如何實作的呢？ 看先代碼！

以下這段代碼來自jdk文檔中demo，寫的非常好！！

class CachedData { Object data; volatile boolean cacheValid; ReentrantReadWriteLock rwl = new ReentrantReadWriteLock(); void processCachedData() { rwl.readLock().lock(); //step1 @hxx 任何人都可以讀資料,因為沒人寫，提高性能 if (!cacheValid) { // @hxx 如果有緩存了，就不用去load資料庫寫緩存了，相當于if(cache.get(key) == null) // Must release read lock before acquiring write lock rwl.readLock().unlock(); // @hxx 為什麼 拿“寫鎖” 前要釋放掉 “讀鎖”？？ 要判斷沒有人拿 “讀鎖” 才可以寫嗎，是這樣實作讀寫互斥的嗎？ 如果是，那麼我在這裡不釋放，是不是就違背了機制，try後，确實是的 rwl.writeLock().lock();

// @hxx 從這裡開始，保證一次隻有一個線程進來啦 begin！！ // Recheck state because another thread might have acquired // write lock and changed state before we did. if (!cacheValid) { data = ... cacheValid = true; } // Downgrade by acquiring read lock before releasing write lock

// @hxx，我先那個讀鎖，哈哈， 在我釋放讀鎖之前，誰也别想拿寫鎖，因為寫鎖拿到的前提是沒有人拿讀鎖 rwl.readLock().lock(); rwl.writeLock().unlock(); // Unlock write, still hold read

// @hxx 從這裡開始，保證一次隻有一個線程進來啦 end！！ } use(data); // step2 @hxx 我在讀資料不怕别人寫，真的爽！ rwl.readLock().unlock(); // @hxx 現在我釋放了讀鎖，去拿寫鎖吧！ } }

ps： 上面代碼。緩存一旦初始化成功後，後續的邏輯就隻會走step1 + step2 了，就隻有讀鎖共享了！

6： ReentrantReadWriteLock.ReadLock 和ReentrantReadWriteLock.WriteLock

看jdk文檔裡面。以為又是一個新的東西，其實就是5中代碼

ReentrantReadWriteLock.writeLock() 傳回的對象

ReentrantReadWriteLock.readLock() 傳回的對象

略過

7： wait(), notify()

java.lang.Object 的方法

檢視該筆記https://note.youdao.com/web/#/file/WEB82c69340fd16ecd931ee5920c6dc88cf/note/WEB384aff600e287fc0656f08883ad894d4/

8： Condition接口 （需要與ReentrantLock配合使用）

條件變量很大一個程度上是為了解決Object.wait/notify/notifyAll難以使用的問題，@hxx也就是消費者生産者代碼中判斷隊列是否滿，是否空的條件！

代碼如下：

private Queue<Integer> buffer = new LinkedList<>();

int max = 100;

int putptr, takeptr, count;

public void put(Object x) throws InterruptedException {

lock.lock();// 先拿鎖

while (max == buffer.size())

notFull.await();

// 不滿，則可以放

buffer.add(1);

// 提醒可以取

notEmpty.signal();

} finally {// 記得釋放鎖

public Object take() throws InterruptedException {

lock.lock();

while (count == 0)

notEmpty.await();

//不空， 可以取

int x= buffer.poll();

// 提醒可放

notFull.signal();

return x;

8： synchronized