学步园

我们知道，在.net的一些集合类型中，譬如Hashtable和ArrayList，都有Synchronized静态方法和SyncRoot实例方法，他们之间有联系吗？我怎么才能用好他们呢？
我们以Hashtable为例，看看他们的基本用法：

            Hashtable ht = Hashtable.Synchronized(new Hashtable());
            lock (ht.SyncRoot)
            {
                //一些操作
            }

1,Synchronized表示返回一个线程安全的Hashtable，什么样的hashtable才是一个线程安全的呢？下边我们就从.NET的源码开始理解。

public static Hashtable Synchronized(Hashtable table)
{
    if (table == null)
    {
        throw new ArgumentNullException("table");
    }
    return new SyncHashtable(table);
}

从源码不难看出，Synchronized方法返回的其实是一个SynchHashtable类型的实例。在前边我们说过，Synchronized表示返回一个线程安全的Hashtable，从这个解释不难看出，SynchHashtable应该是继承自Hashtable。下边我们验证一下。看看SynchHashtable类型的源码：

Code
[Serializable]
private class SyncHashtable : Hashtable
{
    // Fields
    protected Hashtable _table;

    // Methods
    internal SyncHashtable(Hashtable table) : base(false)
    {
        this._table = table;
    }

    internal SyncHashtable(SerializationInfo info, StreamingContext context) : base(info, context)
    {
        this._table = (Hashtable) info.GetValue("ParentTable", typeof(Hashtable));
        if (this._table == null)
        {
            throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientState"));
        }
    }

    public override void Add(object key, object value)
    {
        lock (this._table.SyncRoot)
        {
            this._table.Add(key, value);
        }
    }

    public override void Clear()
    {
        lock (this._table.SyncRoot)
        {
            this._table.Clear();
        }
    }

    public override object Clone()
    {
        lock (this._table.SyncRoot)
        {
            return Hashtable.Synchronized((Hashtable) this._table.Clone());
        }
    }

    public override bool Contains(object key)
    {
        return this._table.Contains(key);
    }

    public override bool ContainsKey(object key)
    {
        return this._table.ContainsKey(key);
    }

    public override bool ContainsValue(object key)
    {
        lock (this._table.SyncRoot)
        {
            return this._table.ContainsValue(key);
        }
    }

    public override void CopyTo(Array array, int arrayIndex)
    {
        lock (this._table.SyncRoot)
        {
            this._table.CopyTo(array, arrayIndex);
        }
    }

    public override IDictionaryEnumerator GetEnumerator()
    {
        return this._table.GetEnumerator();
    }

    public override void GetObjectData(SerializationInfo info, StreamingContext context)
    {
        if (info == null)
        {
            throw new ArgumentNullException("info");
        }
        info.AddValue("ParentTable", this._table, typeof(Hashtable));
    }

    public override void OnDeserialization(object sender)
    {
    }

    public override void Remove(object key)
    {
        lock (this._table.SyncRoot)
        {
            this._table.Remove(key);
        }
    }

    internal override KeyValuePairs[] ToKeyValuePairsArray()
    {
        return this._table.ToKeyValuePairsArray();
    }

    // Properties
    public override int Count
    {
        get
        {
            return this._table.Count;
        }
    }

    public override bool IsFixedSize
    {
        get