C#

lock(_lockObj)
{
   Console.WriteLine("hello!");
}

System.Threading.Monitor.Enter(_lockObj);
try
{
    Console.WriteLine("hello");
}
finally
{
    System.Threading.Monitor.Exit(_lockObj);
}

public class MySingleton
{
  #region Singleton Pattern
  private static volatile MySingleton m_instance;
  private static object m_syncRoot = new object(); // lock target

  public static MySingleton
  {
    get
    {
      if (m_instance == null)
      {
        // Lock the syncroot object, rather than typeof(MySingleton)
        lock (m_syncRoot)
        {
          if (m_instance == null)
          {
            m_instance = new MySingleton();
          }
        }
      }

      return m_instance;
    }
  }
  #endregion
}

public class MyCollection: CollectionBase
{
  private class MySyncCollection: MyCollection
  {
    internal MySyncCollection(MyCollection col)
    {
      m_col = col;
      m_root = col.SyncRoot;
    }

    private MyCollection m_col;
    private object m_root;

    public override object SyncRoot
    {
      get
      {
        return m_root;
      }
    }

    public int Add(object item)
    {
      int index;
      lock (m_root)
      {
        index = m_col.Add(item);
      }
      return index;
    }

    // ... Override other methods ...
  }

  private object m_syncRoot = new object();  // lock target

  public override object SyncRoot
  {
    get
    {
      m_syncRoot;
    }
  }

  public int Add(object item)
  {
    return List.Add(item);
  }

  public static MyCollection Synchronized(MyCollection col)
  {
    if (col == null)
      throw new ArgumentNullException("The specified collection is null. Can not synchronize a non-existent collection.");

    return new MyCollection.MySyncCollection(col);
  }

  // ... Other methods ...
}