實現一個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();
        }
    }
}

輸出結果截圖以下：

而註銷掉加鎖的兩行，則

 

效果很明顯了