计数器线程请求方法

Question

I have many threads, that I implement from the main. My purpose is to limit requests to the server (some methods in the sever class), So I put counter before critical sections and before synchronized. I noticed, that the counter only grows up and never decreases... Thats sample of my code:

private static int currentRequests;
/**
 * @param newStock StockState we are adding to the exist stock states.
 */
public  void addStock(StockState newStock) throws OutOfBoundConcurrentException
{
    if(currentRequests>MaxConcurrentRequests)
        throw new OutOfBoundConcurrentException();          
    System.out.println(currentRequests++);
    synchronized (this) {
    int indx=checkExistStock(newStock.getStockName());          
    if(indx<0)
    {
        stockStates.add(newStock);
        currentRequests--;
        return;
    }
    else
    {
        stockStates.get(indx).updateStockValueFromStockStateClass(newStock.getStockCurrentValue());
    }
    }
    currentRequests--;
}   

Answer 1

In case you have many instances of the class that has the method

void addStock(StockState newStock)

Your counter is broken in regard to thread safety and the behavior of the counter is not guaranteed. Threads that use different instances of the class will not block each other. To fix it you can synchronize the java class instance itself instead.

synchronized(OuterClass.class)

If you are using the lock only for the counter it is much preferred to use an instance of

AtomicLong

It is non-blocking and perform better in an order of magnitudes.

Answer 2

You can do it in 2 ways.

(1) Java AtomicInteger or AtomicLong :

Here you can use decrementAndGet() method in both classes to achieve your goal. Both are synchronization free (non-blocking) operations, achieved by using Compare And Swap algorithms.

(2) Java Semaphore :

You can easily use this one, which is specifically tailored for your kind of requirements requirement ( controlling #no of threads ). In this way, you don't need to reinvent things and also can enjoy the non-blocking nature (same as #1). You can use acquire() and release() methods to control the count.