lock(list) vs. lock(list.syncroot)

  • Thread starter Thread starter Jacob
  • Start date Start date
J

Jacob

Hi there,

Say I have an ArrayList named list. What's the difference between using

lock(list) { .... }

and

lock(list.SyncRoot) { .... }
 
In 1.1, IIRC, there would be no difference as list.SyncRoot was "this".
However, in 2.0, SyncRoot is not "this" but a seperate object. Use SyncRoot
if you want to lock on that. However, I would just use my own syncRoot
object in your containing class.

--
William Stacey [MVP]

| Hi there,
|
| Say I have an ArrayList named list. What's the difference between using
|
| lock(list) { .... }
|
| and
|
| lock(list.SyncRoot) { .... }
|
|
|
|
 
Jacob said:
Say I have an ArrayList named list. What's the difference between using

lock(list) { .... }

and

lock(list.SyncRoot) { .... }
Click to expand...

You may have used ArrayList.ReadOnly or ArrayList.Synchronized to wrap
the list. SyncRoot filters through the wrappers to get the underlying
object.

Generally, ArrayList itself isn't recommended any more, and List<T>
doesn't have a SyncRoot property because it doesn't have virtual methods
- it's not designed for wrapping in the same way as ArrayList, for
performance reasons.

-- Barry
 
William Stacey said:
In 1.1, IIRC, there would be no difference as list.SyncRoot was "this".
However, in 2.0, SyncRoot is not "this" but a seperate object. Use
SyncRoot
if you want to lock on that. However, I would just use my own syncRoot
object in your containing class.
Click to expand...

So it doesn't matter which way I do it as long as I always do it the same
way. Is that right?
 
Jacob said:
So it doesn't matter which way I do it as long as I always do it the same
way. Is that right?
Click to expand...

Like I said, it depends on whether you've got the list wrapped up by
ArrayList.Synchronized or ArrayList.ReadOnly. That's why SyncRoot was
invented.

-- Barry
 
Yes. You can use any object, as long as you use the same one and you know
it does not change behind the covers somehow. For clarity, I would use my
own syncRoot in the class such as this simple example:

public class Class1
{
private readonly object syncRoot = new object();
private readonly List<int> list = new List<int>();

public object SyncRoot
{
get{return this.syncRoot;}
}
public void Add(int i)
{
lock(syncRoot)
{
list.Add(i);
}
}
//...
}

--
William Stacey [MVP]

|
| | > In 1.1, IIRC, there would be no difference as list.SyncRoot was "this".
| > However, in 2.0, SyncRoot is not "this" but a seperate object. Use
| > SyncRoot
| > if you want to lock on that. However, I would just use my own syncRoot
| > object in your containing class.
| >
|
| So it doesn't matter which way I do it as long as I always do it the same
| way. Is that right?
|
|
 
Back
Top