Locking Question around hashtable

[akantrowitz]

In csharp, what is the correct locking around reading and writing into
a hashtable. Note that the reader is not looping through the keys,
simply reading an item out with a specific key:

If i have the following hashtable h which has multiple readers and 1
writer (on different threads) is this the correct locking below:

[Reader]
lock (h.syncroot)
{
string r = h["Test"];
}
msgbox r;

[Writer]
string w = "Mike";
lock (h.syncroot)
{
h["Test"] = w;
}

[Jon Skeet [C# MVP]]

ak*********@hot mail.com wrote:

In csharp, what is the correct locking around reading and writing into
a hashtable. Note that the reader is not looping through the keys,
simply reading an item out with a specific key:

If i have the following hashtable h which has multiple readers and 1
writer (on different threads) is this the correct locking below:

<snip>

If you've just got a single writer and multiple readers, the
documentation states that you don't need any locking. However, I
suspect you *do* need locking if you want to make absolutely sure that
a reader will always see a writer's last write.

You could use a ReaderWriterLoc k for this, although others who have
used this (at least in 1.1 - not sure if it's fixed in 2.0 or not) have
said that ReaderWriterLoc k is so slow that it's usually much faster
just to take an exclusive lock every time (in which case your code is
fine).

Jon

[akantrowitz]

thanks for the response . .heres another followup question:

Lets say i have have a hashtable of hashtables (again on multiple
threads where there is one writer and multiple readers . .)

what would be the correct locking around the code below.

[Reader]
Hashtable n = h["Test'];
string Name = n["Joe"];

[Writer]
hash.Add("Joe", true);
h["Test"] = hash;
Jon Skeet [C# MVP] wrote:

ak*********@hot mail.com wrote:

In csharp, what is the correct locking around reading and writing into
a hashtable. Note that the reader is not looping through the keys,
simply reading an item out with a specific key:

If i have the following hashtable h which has multiple readers and 1
writer (on different threads) is this the correct locking below:

<snip>

If you've just got a single writer and multiple readers, the
documentation states that you don't need any locking. However, I
suspect you *do* need locking if you want to make absolutely sure that
a reader will always see a writer's last write.

You could use a ReaderWriterLoc k for this, although others who have
used this (at least in 1.1 - not sure if it's fixed in 2.0 or not) have
said that ReaderWriterLoc k is so slow that it's usually much faster
just to take an exclusive lock every time (in which case your code is
fine).

Jon

[Michael Nemtsev]

I recomend (till J Skeet did't come and criticise me :)) to use ReaderWriter
lock if only one writer and several readers

Using the ReaderWriterLoc k class, any number of threads can safely read data
concurrently. Only when threads are updating is data locked. Reader threads
can acquire a lock only if there are no writers holding the lock. Writer
threads can acquire lock only if there are no readers or writers holding the
lock.

public class ReadWrite
{
private ReaderWriterLoc k rwl;
private HashTable h;

public ReadWrite()
{
rwl = new ReaderWriterLoc k();
}

public void ReadInts(ref int a, ref int b)
{
rwl.AcquireRead erLock(Timeout. Infinite);
try
{
string r = h["Test"];
}
finally
{
rwl.ReleaseRead erLock();
}
}

public void WriteInts(int a, int b)
{
rwl.AcquireWrit erLock(Timeout. Infinite);

try
{
string w = "Mike";
h["Test"] = w;
}
finally
{
rwl.ReleaseWrit erLock();
}
}
}

"ak*********@ho tmail.com" wrote:

In csharp, what is the correct locking around reading and writing into
a hashtable. Note that the reader is not looping through the keys,
simply reading an item out with a specific key:

If i have the following hashtable h which has multiple readers and 1
writer (on different threads) is this the correct locking below:

--
WBR,
Michael Nemtsev :: blog: http://spaces.msn.com/laflour

"At times one remains faithful to a cause only because its opponents do not
cease to be insipid." (c) Friedrich Nietzsche

[Anders Borum]

> You could use a ReaderWriterLoc k for this, although others who have

used this (at least in 1.1 - not sure if it's fixed in 2.0 or not) have
said that ReaderWriterLoc k is so slow that it's usually much faster
just to take an exclusive lock every time (in which case your code is
fine).

I would like to back this statement with personal experience from a
framework that had to support locking of shared resources. We first went
with the ReaderWriterLoc k but resorted to the lock() statement, because it
was a lot faster (and I really mean a lot).

--
With regards
Anders Borum / SphereWorks
Microsoft Certified Professional (.NET MCP)

[Nick Hounsome]

"Jon Skeet [C# MVP]" <sk***@pobox.co m> wrote in message
news:11******** **************@ f14g2000cwb.goo glegroups.com.. .

ak*********@hot mail.com wrote:

In csharp, what is the correct locking around reading and writing into
a hashtable. Note that the reader is not looping through the keys,
simply reading an item out with a specific key:

If i have the following hashtable h which has multiple readers and 1
writer (on different threads) is this the correct locking below:

<snip>

If you've just got a single writer and multiple readers, the
documentation states that you don't need any locking.

Which documentation?

QUOTE
Thread Safety
To support one or more writers, all operations on the Hashtable must be done
through the wrapper returned by the Synchronized method.

UNQUOTE

[Jon Skeet [C# MVP]]

Nick Hounsome wrote:

If you've just got a single writer and multiple readers, the
documentation states that you don't need any locking.

Which documentation?

QUOTE
Thread Safety
To support one or more writers, all operations on the Hashtable must be done
through the wrapper returned by the Synchronized method.
UNQUOTE

Good question. I *know* that the documentation did at one stage say
that it was safe for a single writer and multiple readers - but I can't
find it now :(

(I seem to remember that at the time that it said it was safe in that
way, the Thread Safety section itself was the standard "instance
members aren't threadsafe" docs, so it was already self-contradictory.)

Jon

[Nick Hounsome]

"Jon Skeet [C# MVP]" <sk***@pobox.co m> wrote in message
news:11******** **************@ f14g2000cwb.goo glegroups.com.. .

Nick Hounsome wrote:

> If you've just got a single writer and multiple readers, the
> documentation states that you don't need any locking.

Which documentation?

QUOTE
Thread Safety
To support one or more writers, all operations on the Hashtable must be
done
through the wrapper returned by the Synchronized method.
UNQUOTE

Good question. I *know* that the documentation did at one stage say
that it was safe for a single writer and multiple readers - but I can't
find it now :(

(I seem to remember that at the time that it said it was safe in that
way, the Thread Safety section itself was the standard "instance
members aren't threadsafe" docs, so it was already self-contradictory.)

You should be OK(ish) provided that you don't add or remove items.
Reading or changing (h[a]=b) should probably be alright but things would go
horribly wrong if a bucket was added or an element chained whilst a read was
in progress without some locking

[Michael Nemtsev]

"Jon Skeet [C# MVP]" wrote:

Nick Hounsome wrote:

If you've just got a single writer and multiple readers, the
documentation states that you don't need any locking.

Which documentation?

Good question. I *know* that the documentation did at one stage say
that it was safe for a single writer and multiple readers - but I can't
find it now :(

Maybe I've read abt ReaderWriterLoc k? Coz it's stated in MSDN that this type
is safe for multithreaded operations

[Nick Hounsome]

"Michael Nemtsev" <Mi************ @discussions.mi crosoft.com> wrote in
message news:53******** *************** ***********@mic rosoft.com...

"Jon Skeet [C# MVP]" wrote:

Nick Hounsome wrote:

> > If you've just got a single writer and multiple readers, the
> > documentation states that you don't need any locking.
>
> Which documentation?

Good question. I *know* that the documentation did at one stage say
that it was safe for a single writer and multiple readers - but I can't
find it now :(

Maybe I've read abt ReaderWriterLoc k? Coz it's stated in MSDN that this
type
is safe for multithreaded operations

It is but we were talking about a bare Hashtable

Also what Jon said about RW locks is generally true - if you are just doing
simple access then locking the whole thing is going to be quicker and
easier - RW locks are only worthwhile if the readers are spending a lot of
time rummaging around in a data structure - tree walking would be the most
common use.