java – 用于同步获取/释放的无锁保护

索引的这个ResourceSet类有一个公共的获取和释放方法,它们都使用同步锁,其持续时间大约相当于生成4个随机数(昂贵,cpu-wise).

因此,从下面的代码中可以看出,我使用AtomicInteger“计数信号量”来防止大量线程在acquire()上同时进入临界区,返回-1(现在不可用)线程太多了.

目前,我使用100的常量作为紧密的CAS循环来尝试增加获取中的原子整数,并将最大线程数的常量设置为10然后允许进入临界区,这足以产生争用.我的问题是,对于中等到高负载的servlet引擎,这些常量应该是什么？有几个线程试图访问这些4K块？

public class ResourceSet {

    // ??? what should this be
    // maximum number of attempts to try to increment with CAS on acquire
    private static final int    CAS_MAX_ATTEMPTS = 50;

    // ??? what should this be
    // maximum number of threads contending for lock before returning -1 on acquire
    private static final int    CONTENTION_MAX = 10;

    private AtomicInteger        latch = new AtomicInteger(0);

    ... member variables to track free resources

    private boolean aquireLatchForAquire ()
    {
        for (int i = 0; i < CAS_MAX_ATTEMPTS; i++) {
            int val = latch.get();
            if (val == -1)
                throw new AssertionError("bug in ResourceSet");        // this means more threads than can exist on any system,so its a bug!
            if (!latch.compareAndSet(val,val+1))
                continue;
            if (val < 0 || val >= CONTENTION_MAX) {
                latch.decrementAndGet();
                // added to fix BUG that comment pointed out,thanks!
                return false;
            }
        }
        return false;
    }

    private void aquireLatchForRelease ()
    {
        do {
            int val = latch.get();
            if (val == -1)
                throw new AssertionError("bug in ResourceSet");    // this means more threads than can exist on any system,so its a bug!
            if (latch.compareAndSet(val,val+1))
                return;
        } while (true);
    }

    public ResourceSet (int totalResources)
    {
        ... initialize
    }

    public int acquire (ResourceTracker owned)
    {        
        if (!aquireLatchForAquire())
            return -1;

        try {
            synchronized (this) {
                ... algorithm to compute minimum free resoource or return -1 if all in use
                return resourceindex;
            }
        } finally {
            latch.decrementAndGet();
        }
    }

    public boolean release (ResourceIter iter)
    {
        aquireLatchForRelease();
        try {
            synchronized (this) {
                ... iterate and release all resources
            }
        } finally {
            latch.decrementAndGet();
        }
    }
}