3

I have a kind of async task managing class, which has an array like this:

public static int[][][] tasks;

Mostly I access the cells like this:

synchronized(tasks[A][B]) {
  // Doing something with tasks[A][B][0]
}

My question is, if I do this:

synchronized(tasks[A]) {
  // ...
}

will it also block threads trying to enter synchronized(tasks[A][B])? In other words, does a synchronized access to an array also synchronizes the accsess to it's cells? If not, how to I block the WHOLE array of tasks[A] for my thread?


Edit: the answer is NO. When someone is in a synchronized block on tasks[A] someone else can simultaniously be in a synchronized block on tasks[A][B] for example - because it's a different object. So when talking about accessing objects from one place at a time, arrays are no different: to touch object X from one place at a time you need to surround it by synchronized(X) EVERYWHERE you touch it.

Improve this question

3 Answers 3

Reset to default
4

No. Each array is an Object (with a monitor) unto itself; and the array tasks[A] is a distinct object from the array tasks[A][B]. The solution, if you want to synchronize all accesses to "sub" arrays of tasks[A] is simply that you must do synchronized (tasks[A]). If all accesses into the descendant objects (say, tasks[A][B]) do this, then any further synchronization is redundant.'

It appears your underlying question is actually something like "how can I safely modify the structure as well as the contents of a data structure while retaining the best concurrency possible?" If you augment your question a bit more about the problem space, we might be able to delve deeper. A three-dimensional array may not be the best solution.

Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

You mean avarywhere I wrote 'synchronized(tasks[A][B])' it must be inside a 'synchronized (tasks[A])'?
I mean that if you protect all accesses into the array with a synchronized(tasks[A]), the finer-grained synchronization is redundant. (This holds in your case where the contents are primitives (ints) not references.) If you don't do this -- some places synchronize with synchronized(tasks[A]) and other places synchronized(tasks[A][B]) you will likely not get the atomicity properties you're looking for. You have to pick a consistent set of locks, and you should probably choose the finest-grain that meets your needs.
@Gene Think of arr[x][y] = q as subarr_x = arr[x]; subarr_x[y] = q (and so on for other nested arrays) -- e.g. it's not an atomic operation nor is it restricted to just one object.
2

int[][][] is an array of arrays of integer arrays, so your synchronized(tasks[A][B]) is synchronizing on the lowest level object, an array of integers, blocking other synchronized access to that same array.

synchronized(tasks[A]) on the other hand is synchronizing the object at the next level up - an array of integer arrays. This prevents synchronized access to that array, which means, in practice that any other code which uses synchronized(tasks[A]) will be blocked - which seems to be what you want, so long as all your acccesses to tasks synchronizes at the same level.

Note that synchronize does not lock anything! However, if two threads attempt to synchronize on the same object, one will have to wait.

It doesn't matter that you then work on another object (your array of integers).

I'm afraid I'm saying that andersoj's answer is misleading. You're doing the right thing.

Improve this answer

1 Comment

I actually found all the answers helpful.. I do use Future in this class by the way (mostly for timeouts), but I like this matrix idea. Thanks all! I believe I got it from here :)
1

Whenever I see code that grabs lots of different mutexes or monitors, my first reaction is to worry about deadlock; in your current code, do you ever lock multiple monitors in the same thread? If so, do you ensure that they are locked in a canonical ordering each time?

It would probably help if you could explain what you are trying to accomplish and how your are using / modifying this tasks array. There are surprising (or perhaps unsurprising) number of cases where the utilities in java.util.concurrent are sufficient, and using individual monitors isn't necessary. Of course, it all depends on what exactlly you are trying to do. Also, if the reason you are trying to grab so many different locks is because you are reading them very frequently, it is possible that using a single read-write lock for the entire 3d jagged-array object might be sufficient for your needs.

Improve this answer

3 Comments

Well, this class manages a number of general task indexes, each one contains a number of sub-task indexes. Each sub-task index contains the number of running sub-tasks of his type. A task is completed if all sub-tasks are completed (all zero). This actually is a matrix of integers, but since Integer++ and Integer-- create new instances and it's trouble inside synchronize, I use int[1] instead. Now, in one of the methods I want to check if a task (tasks[A] for example) is all done, but without having it's sub-tasks updated in the middle of the check. That's why I want to lock all his sub-tasks.
Now if I got andersoj right, I can use synchronized(tasks[A]) but that mean i have to do it everywhere I do synchronized(tasks[A][B])?
@Gene: Strongly suggest looking at the j.u.concurrent package. I suspect a countdownlatch or something similar would be a better solution. Or perhaps collections of Future. Or maybe even a ForkJoinTask.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.