- 同步鎖的本質-排隊
- 同步的方式：獨享鎖-單個隊列窗口，共享鎖-多個隊列窗口
- 搶鎖的方式：插隊鎖(不公平鎖)、先來后到搶鎖(公平鎖)
- 沒搶到鎖的處理方式：快速嘗試多次(CAS自旋鎖)、阻塞等待
喚醒阻塞線程的方式(叫號器)：全部通知、通知下一個
- 區別
- lock:synchronized是一種悲觀鎖，每次都把自己關起來做事，怕被搶而lock底層是CAS樂觀鎖的體現，無所謂外界，如果被搶了，就重新去拿，很樂觀，底層主要靠volatile和CAS實現的
- synchronized:可以保證方法或者代碼塊在運行時同一時刻只有一個線程能進入臨界區，同時保證共享變量對其他線程的可見性
- JDK1.6之前Synchronized是一個重量級鎖，是通過對象內部的一個叫做監視器鎖（monitor）來實現的，但是監視器本質又是依賴于底層的操作系統的Mutex Lock來實現的，而操作系統實現線程之間的切換這就需要從用戶態轉換到核心態,性能低。但是從1.7之后jvm做了很多優化，性能上面差別Lock不多，一般情況下推薦使用synchronized
- 自定義鎖實現
//只是基本demo，還有很多未完善
import java.util.Iterator;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.LockSupport;
public class TonyLock implements Lock {
//判斷一個所得狀態或者說擁有者
volatile AtomicReference<Thread> owner = new AtomicReference<>();
//保存正在等待的隊列
volatile LinkedBlockingQueue<Thread> waiters = new LinkedBlockingQueue<>();
@Override
public boolean tryLock() {
return owner.compareAndSet(null, Thread.currentThread());
}
@Override
public void lock() {
boolean flag = true;
while (!tryLock()) {
if (flag) {
waiters.add(Thread.currentThread());
flag = false;
}else{
LockSupport.park();//while循環，避免偽喚醒
}
}
waiters.remove(Thread.currentThread());
}
@Override
public void unlock() {
//如果現有存儲線程和當前線程是同一個就用null釋放，
if (owner.compareAndSet(Thread.currentThread(),null)) {//釋放成功
Iterator<Thread> iterator=waiters.iterator();
while (iterator.hasNext()) {
LockSupport.unpark(iterator.next());
}
}
}
@Override
public void lockInterruptibly() throws InterruptedException {}
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
return false;
}
@Override
public Condition newCondition() {
return null;
}
}
-
AQS抽象隊列同步器
提供了對資源占用、釋放、線程的等待、喚醒等等接口和具體實現?？梢杂迷诟鞣N需要控制資源爭用的場景中。(ReentrantLock/CountDownLatch/Semphore)
1.png
-
資源占用流程
2.png
//模擬實現簡化版aqs以及使用aqs:官方提供aqs其實也是這樣的思路
public class TonyAQS {
//判斷一個所得狀態或者說擁有者
volatile AtomicReference<Thread> owner = new AtomicReference<>();
//保存正在等待的隊列
volatile LinkedBlockingQueue<Thread> waiters = new LinkedBlockingQueue<>();
volatile AtomicInteger state=new AtomicInteger(0);
//交給使用者去實現，如果不實現，默認會拋異常
public boolean tryAcquire() {
throw new UnsupportedOperationException();
}
public void acquire() {
boolean flag = true;
while (!tryAcquire()) {
if (flag) {
waiters.add(Thread.currentThread());
flag = false;
}else{
LockSupport.park();//while循環，避免偽喚醒
}
}
waiters.remove(Thread.currentThread());
}
public boolean tryRelease() {
throw new UnsupportedOperationException();
}
public void release() {
if (tryRelease()) {
Iterator<Thread> iterator=waiters.iterator();
while (iterator.hasNext()) {
LockSupport.unpark(iterator.next());
}
}
}
}
//使用
public class TonyLock implements Lock {
TonyAQS tonyAQS=new TonyAQS(){
@Override
public boolean tryAcquire() {
return owner.compareAndSet(null, Thread.currentThread());
}
@Override
public boolean tryRelease() {
//如果是可重入的情況下，要判斷資源的占用情況(就是前面一個類未使用的state字段,state字段保存了資源的占用次數，只有次數為0才能進入該釋放)
return owner.compareAndSet(Thread.currentThread(),null);
}
};
@Override
public boolean tryLock() {
return tonyAQS.tryAcquire();
}
@Override
public void lock() {
tonyAQS.acquire();
}
@Override
public void unlock() {
tonyAQS.release();
}
@Override
public void lockInterruptibly() throws InterruptedException {
}
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
return false;
}
@Override
public Condition newCondition() {
return null;
}
}
- 公平鎖和非公平鎖的區別
- 公平鎖：顧名思義–公平，大家老老實實排隊。
- 非公平鎖：只要有機會就嘗試搶占資源
- 非公平鎖的弊端：可能導致后面排隊等待的線程等不到相應的CPU資源，從而引起線程饑餓。
