锁的实现原理解锁的实现加锁的实现

int value = 0;
boolean finish = 0;

//线程A
void store(){
    //A：加锁前的操作
    synchronized(this){ //B：加锁
        value = 1;      //C：写value
        finish = true;  //D：写finish
    }                   //E：解锁
    //F：解锁后的操作
}

//线程B
void load(){
    //G：加锁前的操作
    synchronized(this){ //H：加锁
        if(finish){     //I：读finish
            assert value == 1; //J：读value
        }
    }                   //K：解锁
    //L：解锁后的操作
}

int value = 0;
boolean finish = 0;

//线程A
void store(){
    //A：加锁前的操作
    synchronized(this){ //B：加锁
        loadLoadBarrier();
        loadStoreBarrier();
        value = 1;      //C：写value
        finish = true;  //D：写finish
        storeStoreBarrier();
                        //E：解锁
        storeLoadBarrier();
    }                   
    //F：解锁后的操作
}

//线程B
void load(){
    //G：加锁前的操作
    synchronized(this){ //H：加锁
        loadLoadBarrier();
        loadStoreBarrier();
        if(finish){     //I：读finish
            assert value == 1; //J：读value
        }
        storeStoreBarrier();
                        //K：解锁
        storeLoadBarrier();
    }
    //L：解锁后的操作
}

//在java.util.concurrent.locks.ReentranLock.Sync.tryRelease()
protected final boolean tryRelease(int releases) {
    int c = getState() - releases;
    if (Thread.currentThread() != getExclusiveOwnerThread())//如果当前线程不是该锁的拥有者则抛出异常
        throw new IllegalMonitorStateException();
    boolean free = false;//锁是否可用
    if (c == 0) {//state=0 表示该持有线程完全释放该锁，需要设置free为可用状态以及拥有者线程置空
        free = true;
        setExclusiveOwnerThread(null);
    }
    setState(c);//在释放锁的最后，写state
    return free;
}

storeStoreBarrier();
解锁;
storeLoadBarrier();

//在java.util.concurrent.locks.ReentranLock.FairSync.tryAcquire()
protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();//在加锁的一开始，读state
    if (c == 0) {//锁处于可用状态
        if (!hasQueuedPredecessors() &&
            compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);//设置锁被当前线程拥有
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {//state>0，重入了
        int nextc = c + acquires;
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");//超过最大重入次数2147483648（最大的int）
        setState(nextc);//更新state
        return true;
    }
    return false;
}

加锁;
loadLoadBarrier();
loadStoreBarrier();

//在java.util.concurrent.locks.ReentranLock.NoFairSync.lock()
final void lock() {
    if (compareAndSetState(0, 1))//如果该锁可用，则占有
        setExclusiveOwnerThread(Thread.currentThread());
    else//尝试重入
        acquire(1);
}
//在java.util.concurrent.locks.AbstractQueuedSynchronizer.compareAndSetState()
protected final boolean compareAndSetState(int expect, int update) {
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

//CAS源码：
inline jint Atomic::cmpxchg (jint exchange_value, volatile jint* dest,
        jint compare_value) {
        // alternative for InterlockedCompareExchange
    int mp = os::is_MP();//是否为多核心处理器
    __asm {
        mov edx, dest           //要修改的地址，也就是state变量
        mov ecx, exchange_value //新值值
        mov eax, compare_value  //期待值
        LOCK_IF_MP(mp)          //如果是多处理器，在下面指令前加上LOCK前缀
        cmpxchg dword ptr [edx], ecx//[edx]与eax对比，相同则[edx]=ecx，否则不操作
    }
}