Mutliple threads sharing objects

Question

4.00/5 (1 vote)

See more:

Hi,

Wanted to know if my threads in the illustration below are sharing the same queue and lock:

[code]

C#

class ThreadCls
{
   Queue q = new Queue();
   Threads[] t = new Threads[4];
   object sync = new Object();
   EventWaitHandle ewh = new AutoResetEvent(false);
   
   ThreadCls()
   {
      for(int i = 0; i < 4; i++)
      {
          t[i] = new Thread(doWork);
          t.Start();
      }
   }

   public void getData(object data)
   {
      lock(sync)
      {
          q.Enqueue(data);
      }
      ewh.Set();
   }
   public void doWork()
   {
      while(true)
      {
          lock(sync)
          {
              object o = q.Dequeue();
          }
              // processing logic...
              // etc...

         ewh.WaitOne();
      }
   }
}

Posted 24-Nov-11 17:26pm

d.allen101

Updated 24-Nov-11 19:08pm

Wayne Gaylard

v3

Add a Solution

Comments

Sergey Alexandrovich Kryukov 25-Nov-11 1:29am

I voted 4 (I rarely vote that high for questions :-)): it's basically a right way to do things, but you have some problems I tried to explain in my answer.
--SA

1 solution

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Sergey Alexandrovich Kryukov · Answer 1 · 2011-11-24T19:28:00

The question is pointless. Of course, if you put four threads and the lock and the queue in one class and made them private, which is good, the lock and queue are shared. What to ask about?

I must say, you go in the right direction. I can see three problems:

First, the number 4 is hard-coded and used in two places, which is not supportable: what if you want to change it? You might change is in one place, forget in another one, etc. Always avoid any immediate constants like this 4, use explicit constant defined only in one place for whole solution. But why making it a constant at all? Better yes, abstract it out, make it a parameter of the class. (Also bad name for a class: never use abbreviations).

Second problem: data type object is bad. It will need type casts, which is bad. Make your class generic with data type made a generic parameter.

Third problem: lock is redundant. You need only the event wait handle. In many situation, you can even get a deadlock just because of combination of lock and other synchronization primitives. There is also a well-known idea: over-synchronization is always bad. Some inquirers here asked some question about there solution where they synchronized threads so heavily that they made them completely sequential! Always synchronize exactly as much as needed.

Now, I can offer you two solutions I published here at CodeProject, both very close to your approach but made more accurately. First is a wrapper for the thread (which is I think is a must: using a "bare" thread is bad by many reasons I explain in my solution); another one is generic class for a blocking queue which you can transparently use between threads without any other synchronization primitives.

See:
How to pass ref parameter to the thread[^] (thread wrapper),
change paramters of thread (producer) after it started[^] (thread wrapper example with lock),
Simple Blocking Queue for Thread Communication and Inter-thread Invocation[^].

Good luck,

—SA