實現一個java鎖

AQS是實現java鎖的核心，但是實現起來還是僅僅只需繼承該類重寫它的幾個主要方法即可。

1.首先，定義一個同步類，繼承AQS。

//這里要有個Sync內部類,實現鎖需要繼承AQS
private static class MySync extends AbstractQueuedSynchronizer {
    /**
     * 使用CAS嘗試改變同步狀態,搶鎖就使用cas將當前線程設置狀態為1，設置owner為當前線程
     * @param arg 設置狀態鎖必須要設置為1
     * @return
     */
    @Override
    protected boolean tryAcquire(int arg) {
        if(arg !=1){
            throw new RuntimeException("args 不為1");
        }
        //使用CAS嘗試改變同步狀態
        if(compareAndSetState(0,1)){
            setExclusiveOwnerThread(Thread.currentThread());
            return true;
        }
        return false;
    }

    /**
     * 釋放鎖不需要cas操作
     * @param arg
     * @return
     */
    @Override
    protected boolean tryRelease(int arg) {
        if(getState()==0){
            throw new IllegalMonitorStateException();
        }
        //設置鎖不被任何線程持有
        setExclusiveOwnerThread(null);
        setState(0);
        return true;
    }

    @Override
    protected boolean isHeldExclusively() {
        return getState()==1;
    }
}
2.要實現鎖，自然要定義我自己的鎖了，如下

/**
 * 手動是實現java的鎖機制
 * 這里主要要實現幾個方法：tryLock，lock，unlock
 */
public class MyLock implements Lock {
　　
　　//這里引用剛才的aqs子類
    private 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,time);
    }

    @Override
    public void unlock() {
        mySync.release(1);
    }

    @Override
    public Condition newCondition() {
        return null;
    }
    @Override
    public void lockInterruptibly() throws InterruptedException {

    }
}

好了，僅僅兩個類即可搞定。下面來測試下是否好使。先定義一個線程，使用自己實現的鎖

public class MyThread implements Runnable{

    MyLock myLock = new MyLock();
    @Override
    public void run() {
        try {
            myLock.lock();
            TimeUnit.SECONDS.sleep(3);
            System.out.println(Thread.currentThread().getName()+"\t"+"正在執行..."+ DateUtil.now());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        finally {
            myLock.unlock();
        }

    }
}

最后，測試類如下，我們開啟10個線程小試一把，

/**
 * 測試類
 */
public class Test {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();

        for (int i = 0; i < 10; i++) {
            new Thread(myThread,i+"-thread").start();
        }
    }
}

輸出結果截圖如下：

而注銷掉加鎖的兩行，則

 

效果很明顯了