前面說了這個多，我們可以自己嘗試實現一個同步器，我們可以簡單的參考一下ReentrantLock這個類的實現方式，我們就簡單的實現一個不可重入的獨占鎖吧！
一.簡單分析ReentrantLock的結構
下圖所示，直接實現了Lock這個接口，然后定義了一個內部類繼承AQS，暫時不考慮公平鎖和非公平鎖，前面說AQS的時候說過，留有tryAcquire，tryRelease這兩個方法在具體子類中根據實際情況實現的，可想而知這個內部類主要的是實現tryAcquire，tryRelease；
我們看看Lock接口，這些方法就是我們需要實現的；主要是獲取鎖和釋放鎖，還有一個實現條件變量的方法；
這里注意一下，有的方法后面帶有Interruptibly這種字樣的，這個方法表示如果該線程假如在阻塞隊列中掛起了，這時有另外一個線程去調用這個線程的中斷方法，那么就會立即拋出異常；不帶Interruptibly就是不會對中斷進行響應！
我們如果看看ReentrantLock里面的lock，unlock等方法的實現，可以知道都是調用的Sync的方法，也就是AQS中的一些方法，所以在這里我們可以把Sync看做是一個工具類，我們主要是使用Lock接口的這些方法來實現我們鎖的功能；
二.創(chuàng)建一個鎖MyNonLock
我們只需要創(chuàng)建一個類實現Lock類，然后這個類中有一個內部類MySync繼承AQS，然后在Lock的那些實現方法中調用MySync對象的某些方法就行了；
package com.example.demo.Lock;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
public class MyNonLock implements Lock, java.io.Serializable {
//創(chuàng)建一個具體的MySync來做具體的工作
private final MySync mySync = new MySync();
@Override
public void lock() {
mySync.acquire(1);
}
@Override
public boolean tryLock() {
return mySync.tryAcquire(1);
}
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
return mySync.tryAcquireNanos(1, unit.toNanos(time));
}
//帶了Interruptibly的方法表示對中斷進行響應，就是當一個線程在阻塞隊列中被掛起的時候，
//其他線程調用該線程的中斷方法中斷了該線程，該線程會拋出InterruptedException異常
@Override
public void lockInterruptibly() throws InterruptedException {
mySync.acquireInterruptibly(1);
}
@Override
public void unlock() {
mySync.release(1);
}
//很方便的獲取條件變量
@Override
public Condition newCondition() {
return mySync.newCondition();
}
private static class MySync extends AbstractQueuedSynchronizer {
// 鎖是否已經被持有
protected boolean isHeldExclusively() {
return getState() == 1;
}
// 如果state為0，就嘗試獲取鎖，將state修改為1
public boolean tryAcquire(int acquires) {
assert acquires == 1;
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
// 嘗試釋放鎖，將state設置為0
protected boolean tryRelease(int releases) {
assert releases == 1;
if (getState() == 0) {
throw new IllegalMonitorStateException();
}
setExclusiveOwnerThread(null);
setState(0);
return true;
}
//提供條件變量接口
Condition newCondition() {
return new ConditionObject();
}
}
}
三.生產者消費者模式
我們還可以根據我們自己實現的鎖MyNonLock實現一下生產者消費者模式，注意，這個鎖是不可重入鎖，不需要記錄持有鎖的線程獲取鎖的次數，而且state的值為0表示當前鎖沒有被占用，為1表示已經被占用了；
package com.example.demo.study;
import java.util.Queue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.locks.Condition;
import com.example.demo.Lock.MyNonLock;
public class Study0202 {
// 我們往這個隊列中添加字符串
final static Queue<String> queue = new LinkedBlockingQueue<String>();
// 創(chuàng)建我們自己的鎖對象
final static MyNonLock lock = new MyNonLock();
// 當隊列queue中字符串滿了，其他的生產線程就丟到這個條件隊列里面
final static Condition full = lock.newCondition();
// 當隊列queue是空的，其余的消費線程就丟到這個條件隊列里面
final static Condition empty = lock.newCondition();
// 隊列queue中存字符串最多只能是3個
final static int queue_MAX_SIZE = 3;
//往隊列queue中壓入字符串
public static void add() {
lock.lock();
try {
// 當隊列滿了，就將其他生產線程丟進full的條件隊列中
while (queue.size() == queue_MAX_SIZE) {
full.await();
}
System.out.println("prd:" + "hello");
// 往隊列queue中添加字符串
queue.add("hello");
// 生產成功，喚醒消費條件隊列中的所有線程趕緊去消費
empty.signalAll();
} catch (Exception e) {
//
} finally {
lock.unlock();
}
}
//從隊列queue彈出字符串
public static void poll() {
lock.lock();
try {
// 當隊列queue中一個字符串都沒有，就將剩下的消費線程丟進enpty對應的隊列中
while (queue.size() == 0) {
empty.await();
}
// 消費隊列queue中的字符串
String poll = queue.poll();
System.out.println("consumer:" + poll);
// 消費成功，就喚醒full中所有的生產線程去生產字符串
full.signalAll();
} catch (Exception e) {
//
} finally {
lock.unlock();
}
}
public static void main(String[] args) {
// 生產者線程
for (int i = 0; i < 5; i++) {
new Thread(() -> {
add();
}).start();
}
// 消費者線程
for (int i = 0; i < 5; i++) {
new Thread(() -> {
poll();
}).start();
}
}
}
可以看到隊列中最多只能是3個字符串，最后都能被消費完畢！
以上就是基于AQS實現一個同步器的詳細內容，更多關于AQS實現同步器的資料請關注服務器之家其它相關文章！
原文鏈接：https://www.cnblogs.com/wyq1995/p/12256550.html
