System.Collecti ons.Generic.Que ue & System.Collecti ons.Queue Synchronized Method

[nhmark64]

Hi,

Does System.Collecti ons.Generic.Que ue not have a Synchronized
method because it is already in effect synchronized, or is the
Synchronized functionality missing from
System.Collecti ons.Generic.Que ue? Putting it another way can I
safely replace a
System.Collecti ons.Queue.Synch ronized(myUnSyn chronizedQueue) with a
System.Collecti ons.Generic.Que ue while porting a working 2003 project?
Thanks,
Mark

[William Stacey [MVP]]

The Queue<T> is not thread safe.
"Public static (Shared in Visual Basic) members of this type are thread
safe. Any instance members are not guaranteed to be thread safe.

A Queue can support multiple readers concurrently, as long as the collection
is not modified. Even so, enumerating through a collection is intrinsically
not a thread-safe procedure. To guarantee thread safety during enumeration,
you can lock the collection during the entire enumeration. To allow the
collection to be accessed by multiple threads for reading and writing, you
must implement your own synchronization ."

I would provide your own syncRoot and lock on that during instance method
calls.
--
William Stacey [MVP]
<nh******@newsg roup.nospam> wrote in message
news:4r******** *************** *********@4ax.c om...
| Hi,
|
| Does System.Collecti ons.Generic.Que ue not have a Synchronized
| method because it is already in effect synchronized, or is the
| Synchronized functionality missing from
| System.Collecti ons.Generic.Que ue? Putting it another way can I
| safely replace a
| System.Collecti ons.Queue.Synch ronized(myUnSyn chronizedQueue) with a
| System.Collecti ons.Generic.Que ue while porting a working 2003 project?
| Thanks,
| Mark

[nhmark64]

Hi,

Thanks for your help.

I can safely replace 2003 C#

static System.Collecti ons.Queue myUnSynchronize dQueue=new
System.Collecti ons.Queue();
static System.Collecti ons.Queue
mySynchronizedQ ueue=System.Col lections.Queue. Synchronized(my UnSynchronizedQ ueue);
void f() {
lock(mySynchron izedQueue.SyncR oot)
{
IEnumerator myEnumerator=my SynchronizedQue ue.GetEnumerato r();
}
}

with 2005 C#

static System.Collecti ons.Generic.Que ue<myType>
mymSynchronized Queue=new System.Collecti ons.Generic.Que ue<myType>();

void f() {

lock(mySynchron izedQueue)
{
IEnumerator<myT ype>
myEnumerator=my SynchronizedQue ue.GetEnumerato r();
}
}

without any other code modifications (except removing unnecessary
type casts) while porting a working 2003 project?

Thanks,
Mark
On Wed, 15 Feb 2006 03:42:24 -0500, "William Stacey [MVP]"
<wi************ @gmail.com> wrote:

The Queue<T> is not thread safe.
"Public static (Shared in Visual Basic) members of this type are thread
safe. Any instance members are not guaranteed to be thread safe.

A Queue can support multiple readers concurrently, as long as the collection
is not modified. Even so, enumerating through a collection is intrinsically
not a thread-safe procedure. To guarantee thread safety during enumeration,
you can lock the collection during the entire enumeration. To allow the
collection to be accessed by multiple threads for reading and writing, you
must implement your own synchronization ."

I would provide your own syncRoot and lock on that during instance method
calls.

[Jon Skeet [C# MVP]]

nh******@newsgr oup.nospam wrote:

I can safely replace 2003 C#

static System.Collecti ons.Queue myUnSynchronize dQueue=new
System.Collecti ons.Queue();
static System.Collecti ons.Queue
mySynchronizedQ ueue=System.Col lections.Queue. Synchronized(my UnSynchronizedQ ueue);
void f() {
lock(mySynchron izedQueue.SyncR oot)
{
IEnumerator myEnumerator=my SynchronizedQue ue.GetEnumerato r();
}
}

with 2005 C#

static System.Collecti ons.Generic.Que ue<myType>
mymSynchronized Queue=new System.Collecti ons.Generic.Que ue<myType>();

void f() {

lock(mySynchron izedQueue)
{
IEnumerator<myT ype>
myEnumerator=my SynchronizedQue ue.GetEnumerato r();
}
}

without any other code modifications (except removing unnecessary
type casts) while porting a working 2003 project?

Neither of those will give you thread-safe enumeration. You need to
hold the lock throughout the duration of the enumeration - not just for
the call to GetEnumerator() .

If the above is called, and then another thread modifies the collection
before the enumerator is actually used (or during its use) you'll get
an exception when you use the enumerator.

Jon

[nhmark64]

Thanks,
Mark

On 15 Feb 2006 23:58:27 -0800, "Jon Skeet [C# MVP]" <sk***@pobox.co m>
wrote:

nh******@newsg roup.nospam wrote:

I can safely replace 2003 C#

static System.Collecti ons.Queue myUnSynchronize dQueue=new
System.Collecti ons.Queue();
static System.Collecti ons.Queue
mySynchronizedQ ueue=System.Col lections.Queue. Synchronized(my UnSynchronizedQ ueue);
void f() {
lock(mySynchron izedQueue.SyncR oot)
{
IEnumerator myEnumerator=my SynchronizedQue ue.GetEnumerato r();
}
}

with 2005 C#

static System.Collecti ons.Generic.Que ue<myType>
mymSynchronized Queue=new System.Collecti ons.Generic.Que ue<myType>();

void f() {

lock(mySynchron izedQueue)
{
IEnumerator<myT ype>
myEnumerator=my SynchronizedQue ue.GetEnumerato r();
}
}

without any other code modifications (except removing unnecessary
type casts) while porting a working 2003 project?

Neither of those will give you thread-safe enumeration. You need to
hold the lock throughout the duration of the enumeration - not just for
the call to GetEnumerator() .

If the above is called, and then another thread modifies the collection
before the enumerator is actually used (or during its use) you'll get
an exception when you use the enumerator.

Jon