Synchronizing on multiple objects

Question

I have a situation as listed below.
My code is multithreaded. I need to protect the data in mMyMap.
I have other methods that can access the data in mMyMap.
If I were just using 1 object, I lock access to the object by locking the key (it's a global single instance).
However I need to grab multiple instances, and then process them.
I want to do something like:
synchronized (listOfObjects) {
but I need to lock the values IN the list, not the list object iteself.
Are there any tricks to accomplish this?
Thanks
private Map mMyMap;
private void doStuff() {
List list = new ArrayList()
for (int i=0; i<3; i++) {
Key k = singleton_key_instance(i);
Object o = mMyMap.get(k);
doSomeStuff(o);
list.add(o);
stampObjects(list);
private void stampObjects(List objects) {
Iterator itr = objects.iterator();
while (itr.hasNext()) {
Object o = itr.next();
stampIt(o);
/------------

Answer 1

If all your access to the objects looks like this
.k = getKeySomehow();
.synchronized (k) {
.    Object o = getFromMap(k);
.    do stuff with 'o';
.}And you never get as 'o' without first syncing on its key, and all the "do stuff with 'o'" is inside that sync block, then at any time, at most one thread can be accessing a given 'o' as long as only one key maps to a given 'o'.
My comment above was that holding the lock for a particular key didn't affect another thread doing anything with the map. Note that while thread T1 is in the sync block above, T2 can concurrently enter the same block for a different key.
If you really want to protect the 'o's though, you may be better off like this:
.k = getKeySomehow();
.Object o = getFromMap(k);
.synchronized (o) {
.    do stuff with 'o';
.}I guess it depends on whether o's methods are synchronized, and whether you really need to prevent anybody from even getting an o while another thread is in the processing block.
But... back to the code as you showed it. As I said, if the only way to get an o is through the key, and if no two keys refer to the same o, then that should do to make sure only one thread at a time fiddles with an o. So, what is your question? Is it just whether that scheme will work?