Allowing only two thread to operate on a function

I have an unusual problem. I have a function, operation in this function can be done by two threads at a time.

static int iCount = 1;
public synchronized void myFunct(){ 
while(iCount >= 3)
{
   try {
       wait();
   } catch (InterruptedException e) {
       e.printStackTrace();
 }

 iCount++; 

 //Do Stuffs
 //After operation decrement count

 iCount --开发者_运维百科;
 notifyAll();
}

What i am trying to do is, i want to allow only two threads to do some operation, and other threads must wait.

But here first two threads increment the count and does the operation and other threads go for an wait state but do not get the notification.

I guess i am overlooking something.

Sounds like you want to use a Semaphore, you always call acquire() before doing your operation, and then release() in a finally block.

private static final Semphore semaphore = new Semaphore(2);

public static void myFunct() throws InterruptedException {
    semaphore.aquire();
    try {
        // do stuff
    } finally {
        semaphore.release();
    }
}

Your function is synchronized, so only one thread at a time can be in it.

I'm not sure I understand your question... But if you want to allow two threads to go somewhere at once, have a look at Semaphore.

Is this a singleton class? If not then it's a problem because many concurrent instances may change the value of icounter and in addition they will block on it forever because no thread will be able to call notify on their instance object.

Anyway you should move the sync inside the function and lock iCount and not the instance, also make it volatile.

public void myFunct(){ 
synchronized(iCount) {
while(iCount >= 3)
{
   try {
       wait();
   } catch (InterruptedException e) {
       e.printStackTrace();
 }
}
iCount++; 
}
//Do Stuffs
 //After operation decrement count
synchronized(iCount) {
 iCount--;
}
 notifyAll();

Why aren't you just using a Semaphore?

An alternative might be to use a ThreadPoolExecutor with a maximum of two threads.

You need java.util.concurrent.Semaphore, initialized with 2 permits.

As for your current code - threads may cache values of variables. Try adding the volatile keyword.

There are many problems with this code. Among them:

1. You have no real control on the number of threads running myFunct, since the method is synchronized on the instance level, while the counter is static. So N different threads operating on N different instances may run the same method concurrently.

2. Manipulating the counter by multiple threads is not thread safe. Consider synchronizing it or using AtomicInteger.

Regarding the limit on the number of threads, consider using the Semaphore class.