在java中使用信号量并存储到数组中

Question

I am new to using semaphores, so bear with me please. So, lets say I have 7 permits to give out and 49 people(threads) in total are waiting for them. If I acquire() the semaphores for the first 7 people and store them into a list array(store the semaphores of people) for instance by passing them into another class. Then if I go back into that array and loop through and release() the semaphores within that other class, shouldn't that then trigger the other threads waiting to take that next key? Because what I just coded did this and the next 7 threads don't acquire the key. I didn't post the code because I just want to conceptually understand what I am missing out on, and then implement it.

Answer 1

If what you want is to have max 7 threads to be active at one time, you only need 1 semaphore, like this:

Semaphore available = new Semaphore(7, true);

and let each of your threads call available.acquire() (and eventually available.release() ), against this very semaphore instance (shared by all the threads), and that is it.

Here is what java.util.concurrent.Semaphore javadoc says:

A counting semaphore. Conceptually, a semaphore maintains a set of permits. Each acquire() blocks if necessary until a permit is available, and then takes it. Each release() adds a permit, potentially releasing a blocking acquirer. However, no actual permit objects are used; the Semaphore just keeps a count of the number available and acts accordingly.

Answer 2

If you're acquiring a semaphore, be sure to release it at some point as well. ex Pseudo code:

sem = Semaphore.new(2, true)
Thread1 { 
    sem.acquire()
    // Do something
    sem.release()
    }; 
Thread2 { 
    sem.acquire()
    // Do something
    sem.release()
    }
Thread3 { 
    //blocked until one of the first two Thread releases. 
    sem.acquire()
    // Do something
    sem.release()
    }

This is adding to zeppelin's point...