Re: Concurrent bidirectional one-to-many map?
Sebastian wrote:
schrieb Tom Anderson:
Robert Klemme wrote:
Tom Anderson wrote:
Sebastian wrote:
...
To give an example, I'm trying to solve a problem like this:
Associate tasks with workspaces, where a workspace may hold many
tasks,but a task may be associate with at most one workspace.
...
This could be solved by standard relationship implementations: Make
workspace a member of Task and synchronize accesses on Task. Example:
https://gist.github.com/962538
By using monitors of Task and Workspace we have quite fine granularity
of locking.
True! The fastest map is no map at all.
If the OP can't modify Task or Workspace, perhaps he could consider
writing wrappers which refer to each other, a TaskWithWorkspace, and
WorkspaceWithTasks (perhaps with better names), and passing those around
rather than plain Tasks and Workspaces.
I can't modify Task, or Workspace, and I won't do much "passing around"
either, as I'm writing a component that will be called remotely (over
RMI). But I suppose I could create a wrapper object for each
Item/Workspace on the first call and look them up in maps indexed on
the Item/Workspace id. Now I wonder if I just have shifted the problem
to these maps?
I'll have to brush up on "monitors" and look at the example.
As for access patterns, that will depend on worker behavior. If they are
well-behaved, they won't competemuch for tasks and finish them quickly, so I'd
hope for about as many writes as reads.
"Monitor", very loosely speaking, is Javaese for "lock". More specifically,
every object in Java has a built-in lock that has the properties of a Hoare
monitor. I can't be bothered to look that up right now, but for us workaday
Java programmers it means that thing that 'synchronized' locks.
public class Lockaday
{
private static final State state = new State();
synchronized // class object's monitor
public static void setState( State newState )
{
state.copy( newState );
}
synchronized // class object's monitor
public static State getState()
{
return state.clone();
}
private final Object lock = new Object();
private Attribute attribute;
public void setAttribute( Attribute newAttr )
{
synchronized ( lock ) // monitor of instance that 'lock' references
{
attribute = newAttr;
}
}
public Attribute getAttribute()
{
synchronized ( lock ) // monitor of instance that 'lock' references
{
return attribute;
}
}
}
--
Lew
Honi soit qui mal y pense.
http://upload.wikimedia.org/wikipedia/commons/c/cf/Friz.jpg