I have a `shared string[int]` AA that I access from two different
threads. The function I spawn to start the second thread takes
the AA as an argument.
```d
class Foo
{
shared string[int] bucket;
Tid worker;
}
void workerFn(shared string[int] bucket)
{
while (true)
{
// occasionally reads, occasionally modifies bucket
}
}
void main()
{
auto foo = new Foo;
foo.bucket[0] = string.init;
foo.bucket.remove(0);
foo.worker = spawn(&workerFn, foo.bucket);
while (true)
{
// occasionally reads, occasionally modifies bucket
}
}
```
(`run.dlang.io` shortening seems broken again, but I made a
[gist](https://gist.github.com/zorael/17b042c424cfea5ebb5f1f3120f983f4) of a more complete example.)
Reading the specs on `synchronized` statements, it seems I need
to provide an `Object` to base synchronisation on when two
*different* places in the code needs synchronising, whereas if
it's in the same place an expressionless `synchronize { }` will
do.
The worker function can't see `Foo foo` inside `main`, so it
can't share synchronisation on that.
What is the common solution here? Do I add a module-level `Object
thing` and move everything accessing the AA into
`synchronized(.thing)` statements? Or maybe add a `shared static`
something to `Foo` and synchronise with `synchronize(Foo.thing)`?
