C#

public class ThreadTest
{
  public event EventHandler MyEvent;

  public void Start()
  {
    Thread thread = new Thread(new ThreadStart(this.ThreadMethod));
    thread.Start();
  }

  private void ThreadMethod()
  {
    while (true)
    {
      Thread.Sleep(1000);
      if (MyEvent != null) MyEvent(this, EventArgs.Empty);
    }
  }
}

public class Subscriber
{
  public void Run()
  {
    // As a subscriber to ThreadTest.MyEvent I know that whatever
    // delegate I specify for the handler will be executing on an
    // unknown thread. I must take care of my own synchronization.

    ThreadTest test = new ThreadTest();
    test.MyEvent += new EventHandler(this.OnEvent);
    test.Start();
    test.Start();
    test.Start();

    // Continue with the whatever else you need to do here...
  }

  public void OnEvent(object source, EventArgs e)
  {
    // It is NOT safe to access shared members here.

    lock (this)
    {
      // It is safe to access shared members here.
    }
  }
}

if (<code>Event </code>!= null){
      <code>Event</code>(<code>this</code>, <code>e</code>);    
   }

lock(this){
if (<code>Event </code>!= null){
      <code>Event</code>(this, e);    
   }
}

lock(<code>Event</code>){
if (<code>Event </code>!= null){
      <code>Event</code>(this, e);    
   }
}

lock(this) {
  if (Event != null) {      
    Event(this, e);
  }
}

public class ThreadTest
{
  private ArrayList _events = new ArrayList();

  public event EventHandler MyEvent
  {
    add { lock (this) { _events.Add(value); } }
    remove { lock (this) { _events.Remove(value); } }
  }

  public void Start()
  {
    // Same code as before
  }

  private void ThreadMethod()
  {
    while (true)
    {
      ArrayList clone;
      lock (this)
      {
        clone = (ArrayList)_events.Clone();
      }
      foreach (EventHandler e in clone)
      {
        e.DynamicInvoke(...);
      }
    }
  }
}

public void Call(A caller)
{
  object callerr = caller;
}