自定義同步鎖的實現

自定義同步鎖的實現

本文出自《java 併發編程的藝術》

在多線程訪問資源的時候分爲獨佔式與共享式，本例子是一個基於AbstractQueuedSynchronizer的自定義同步鎖；
關於AbstractQueuedSynchronizer的實現原理，其實就是內部維護了一個雙向隊列，在本例子中，如果線程未獲取到鎖的時候會發生自旋。
一下是自定義同步鎖的實現：

package com.kangxin.doctor.connectdemo;

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 TwinsLock implements Lock {

    private final Sync sync = new Sync(2);
    @Override
    public void lock() {
        sync.acquireShared(1);
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {

    }

    @Override
    public boolean tryLock() {
        return false;
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }

    @Override
    public void unlock() {
        sync.releaseShared(1);
    }

    @Override
    public Condition newCondition() {
        return null;
    }

    private static final class Sync extends AbstractQueuedSynchronizer{

        Sync(int count) {
            if (count <=0){
                throw new IllegalArgumentException("count must large than zero.");
            }

            setState(count);
        }

        @Override
        protected int tryAcquireShared(int reduceCount) {

            for (;;){
                int current = getState();
                int newCount = current - reduceCount;
                if (newCount < 0 || compareAndSetState(current, newCount)){
                    return newCount;
                }
            }
        }

        @Override
        protected boolean tryReleaseShared(int returnCount) {

            for (;;){
                int current = getState();
                int newCount = current + returnCount;
                if (compareAndSetState(current, newCount)){
                    return true;
                }
            }
        }
    }
}

可以看到在這個類中有一個自定義的內部類的實現，該Sync實現了AbstractQueuedSynchronizer的tryAcquireShared方法，由此可知線程的訪問模式是共享式，只不過要根據構造傳入的count來控制共享的線程數量，假設傳入的是2的話，那麼只允許兩個線程共享資源，其他的處於阻塞；
下面通過一個例子來說明一下，這個例子創建來10個線程，只允許兩個線程去共享資源，當前線程處理完操作之後釋放鎖, 好讓其他阻塞的線程來訪問資源。

package com.kangxin.doctor.connectdemo;

import java.util.concurrent.locks.Lock;

public class ShareSyncTest {
    public static void main(String[] args) {
        final Lock lock = new TwinsLock();

        class Worker extends Thread{
            @Override
            public void run() {

                while (true){
                    lock.lock();

                    try {
                        SleepUtil.second(1);
                        System.out.println(Thread.currentThread().getName());
                        SleepUtil.second(1);
                    }finally {
                        lock.unlock();
                    }
                }
            }
        }

        for (int i=0; i < 10; i++){
            Worker w= new Worker();
            w.setDaemon(true);
            w.start();
        }

        for (int i=0; i < 10; i++){
            SleepUtil.second(1);
            System.out.println();
        }
    }

}

從代碼這可以看到在線程裏面我們用來一個循環類處理，開始的時候獲取鎖然後睡眠來1秒之後打印來一下線程名字然後再睡眠一秒之後釋放了鎖；該示例運行起來之後會發現每隔2秒會同時打印2個線程信息。

效果如下

Thread-0

Thread-1


Thread-1
Thread-0

Thread-0

Thread-1

Thread-0
Thread-1


Thread-0
Thread-1