Concurrency with locks and wait/signal. Is it ok?

Question

Hello,
I'm relatively new in concurrency. I've write this code that seems to work, but I'm not sure if there is any error (the concurrency concepts are not still clear for me).
In the following class "diskFile", I'll start 10 threads executing the class "diskCacheDataOneCall". The question is that the "populateCacheFromDisk" method should wait until 10 threads are finished and, if any thread produces an error, interrupt all threads and finish.
The code seems to work, but I have some questions like if I should synchronize the static variables Lock and Condition before using them.
Anyway, I'd like that an "expert" on concurrency tells me if this code is acceptable, or what kind of improvements can do (or, if there is some mistake, how to correct it).
I've spent many time reading tutorials about concurrency, and this is the result. Really, I'm not sure if I'm doing the things well, that's why I need the opinion of an expert in order to get better on concurrency.
Thanks in advance.
public class diskFile
// Static variables for threading.
public static Lock lock = null;
public static Condition cdFinished = null;
public static int numActiveThreads = 0;
public static Exception loadException = null;
// Main function
public static void populateCacheFromDisk() throws cacheServletException
ArrayList<Thread> arrThread = new ArrayList<Thread>();
// Init static variables.
lock      = new ReentrantLock();
cdFinished      = lock.newCondition();     
numActiveThreads = 0;
loadException = null;
try
// Iterate 10 times (for simplicity) ...
for (int i = 0; i < 10; i++)
// Create THREAD and store its reference
Thread thr = new Thread(new diskCacheDataOneCall());
thr.start();
arrThread.add(thr);
// Increment "numActiveThreads"
lock.lock();
numActiveThreads++;
lock.unlock();
// Her we wait while no error happens and still active threads
lock.lock();
while ( (loadException == null) && (numActiveThreads > 0) )
cdFinished.await();
// If an error happens in any thread, then interrupt every active thread.
if (loadException != null)
for (int i = 0; i < arrThread.size(); i++)
Thread thr = arrThread.get(i);
if (thr.isAlive()) thr.interrupt();
throw loadException;
catch (Exception e) { throw new cacheServletException(); }
finally { lock.unlock(); }
public class diskCacheDataOneCall implements Runnable
public diskCacheDataOneCall() {}     
public void run()
try
     diskFile.getCacheDataFromDiskOneCall(); // Load data from disk.
// Decrement "numActiveThreads"
     diskFile.lock.lock();
     diskFile.numActiveThreads--;
catch (Exception e)
diskFile.lock.lock();
diskFile.loadException = e;
finally
// Always signal and unlock.
diskFile.cdFinished.signal();
diskFile.lock.unlock();
}

Answer 1

Hello David,
Sorry but the code does not work. An IllegalMonitorStateException is throwed. Here I show you a simplified version (now with ThreadPoolExecutor):
   // Main class (it triggers "maxActive" threads)
   Lock lock  = new ReentrantLock();
   Condition cdFinished = lock.newCondition();       
   numActiveThreads = 0;
   loadException = null;
   try
    ExecutorService ex = Executors.newFixedThreadPool(numActiveThreads);
    for (int i = 0; i < numActiveThreads; i++) ex.execute(arrTasks.get(i));
    lock.lock();
    while ( (loadException == null) && (numActiveThreads > 0) )
               cdFinished.await();
    ex.shutdown();
   catch (Exception e) { throw e; }
   finally { lock.unlock(); }
  // Every thread.
  public void run()
   try
    doSomething();
    diskFile.lock.lock();
    diskFile.numActiveThreads--;
   catch (Exception e)
    diskFile.lock.lock();
    diskFile.loadException = cse;
   finally
    diskFile.cdFinished.signal();
    diskFile.lock.unlock();
  }The exception is:
// Fail in the "signal" (finally section)
Exception in thread "pool-1-thread-1" java.lang.IllegalMonitorStateException
at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.signal(AbstractQueuedSynchronizer.java:1666)
at com.vcfw.cache.cache.disk.diskCacheDataOneCall.run(diskCacheDataOneCall.java:44)
at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:650)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:675)
at java.lang.Thread.run(Thread.java:595)
// Fail in the "unlock" (finally section)
Exception in thread "pool-1-thread-2" java.lang.IllegalMonitorStateException
at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(ReentrantLock.java:125)
at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(AbstractQueuedSynchronizer.java:1102)
at java.util.concurrent.locks.ReentrantLock.unlock(ReentrantLock.java:431)
at com.vcfw.cache.cache.disk.diskCacheDataOneCall.run(diskCacheDataOneCall.java:43)
at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:650)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:675)
at java.lang.Thread.run(Thread.java:595)
Some threads fail executing the signal, and some threads fail executing ythe unlock. An IllegalMonitorStateException seems to mean that the lock was not acquired by the thread, but I'm not able to see the mistake.
Can you help me?
Thanks.