基於AQS本身實現一個同步器

　　前面說了這個多，咱們能夠本身嘗試實現一個同步器，咱們能夠簡單的參考一下ReentrantLock這個類的實現方式，咱們就簡單的實現一個不可重入的獨佔鎖吧！

 

一.簡單分析ReentrantLock的結構

 　　下圖所示，直接實現了Lock這個接口，而後定義了一個內部類繼承AQS，暫時不考慮公平鎖和非公平鎖，前面說AQS的時候說過，留有tryAcquire，tryRelease這兩個方法在具體子類中根據實際狀況實現的，可想而知這個內部類主要的是實現tryAcquire，tryRelease；

 

 

　　咱們看看Lock接口，這些方法就是咱們須要實現的；主要是獲取鎖和釋放鎖，還有一個實現條件變量的方法；

　　這裏注意一下，有的方法後面帶有Interruptibly這種字樣的，這個方法表示若是該線程假如在阻塞隊列中掛起了，這時有另一個線程去調用這個線程的中斷方法，那麼就會當即拋出異常；不帶Interruptibly就是不會對中斷進行響應！

 

 

　　咱們若是看看ReentrantLock裏面的lock，unlock等方法的實現，能夠知道都是調用的Sync的方法，也就是AQS中的一些方法，因此在這裏咱們能夠把Sync看作是一個工具類，咱們主要是使用Lock接口的這些方法來實現咱們鎖的功能；

 

 

 

 

二.建立一個鎖MyNonLock

　　咱們只須要建立一個類實現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 {
    
    //建立一個具體的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>();
    // 建立咱們本身的鎖對象
    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個字符串，最後都能被消費完畢！