两个线程同时访问同一ArrayList？

Question

I have the following code in thread 1:

synchronized (queues.get(currentQueue)) {            //line 1
   queues.get(currentQueue).add(networkEvent);       //line 2
}

and the following in thread 2:

synchronized (queues.get(currentQueue)) {
   if (queues.get(currentQueue).size() > 10) {
      currentQueue = 1;
   }
}

Now to my question: The currentQueue variable currently has the value of 0. When thread 2 changes the value of currentQueue to 1 and thread 1 waits at line 1 (because of the synchronized), does thread 1 then use the updated currentQueue value in line 2 after thread 2 has finished (that's what I want to).

Answer 1

The correct answer to your question is: The result is undefined.

Your monitor object is queues.get(currentQueue), but since currentQueue is variable, your monitor is variable, therefore the state it is currently in is more or less random. Effectively this code would break eventually.

A simple way to fix it would be a function like this:

protected synchronized QueueType getCurrentQueue() {
  return queues.get(currentQueue);
}

However this is still a bad way of implementing the whole thing. You should either try to eliminate the synchronization completely through the use of a concurrent Queue (like ConcurrentLinkedQueue) or work with a lock/final monitor object.

final Object queueLock = new Object();
...
synchronized(queueLock) {
  queues.get(currentQueue).add(networkEvent);
}

Note that you will have to use that locking every time you access queues or currentQueue as both define the dataset you are using.

Answer 2

The answer to the question is that it depends. I assume there is other chunk of code that increments the currentQueue variable. This being the case, the lock is happening not at the ' currentQueue ' variable and neither is it happening at the collection of ' queues ', but rather it is happening on one of the 10 queues (or however many you have) in the ' queues ' collection.

Hence, if both threads happen to access the same queue (say queue 5), then the answer to your question is yes. However, for that to happen is one in ten chance (one in x chance, where x = the number or queues in the ' queues ' collection). Therefore, if the threads access different queues, then the answer is no.

Answer 3

Assuming you have no other thread will change the value of currentQueue, yes Thread 1 will end up using the queue pointed to by the updated value of currentQueue , since you're invoking queues.get(currentQueue) once again in the body of the synchronized block. This however doesn't mean that your synchronization is sound. You actually should synchronize on currentQueue, since it seems to be the shared key to access the current queue.

Also remember when you use synchronize you're synchronizing on the reference of the variable, and not its value. So if you reassign a new object to it, your synchronization doesn't make sense anymore.