Question

My understanding of this is that a synchronized block keeps other threads from accessing until such time as that block terminates; that is, they are put on hold till then via a lock held by the currently executing class (?).

So I wrap a for block which iterates over a list and then calls clear() on that list directly thereafter, in a synchronized block. as I can’t afford to have other threads adding to the list between those two sets of operations. This is in accordance with the docs, which say,

It is imperative that the user manually synchronize on the returned
collection when iterating over it…

However I can’t figure for sure whether I need to do the same when I am adding to the list. I am guessing not, since in my case the order of add operations from different threads is not important. I guess that what I’m unsure of is whether unsynchronized modify operations might have any negative impacts?

Answer 1

You only need locking when you have multiple operations which must work together. In the case of an Iterator, you will perform any operations over the life of the loop.

If adds can occur in any order, no additional locking is required.

I wrap a for block which iterates over a list and then calls clear()

From your use case, it sounds like a BlockingQueue (is thread safe without synchronized) or even an ExecutorService (which combines a thread pool with a queue) would be a better choice.