深入解析Hashtable的线程同步问题

在我们最熟悉的概念里，我们都知道相对于Hashmap而言，Hashtable的处理效率更慢，因为Hashtable引入了多线程安全机制，所以在处理键值对的时候，效率很慢。

但事实上Hashtable本身是没有实现serializable接口，也就是说它本身在多线程的机制中并不是线程安全的。

然而，在真正的应用开发上，当我们需要用到多线程的Hashtable时，我们都会在创建的时候引入同步概念，使得Hashtable变成线程安全的，详细代码解析如下：

[html]  view plain  copy

1. class HashTableIsNot    
2.   {    
3.       private Hashtable a = new Hashtable();//不是线程安全的   

[html]  view plain  copy

1. <span style="white-space:pre">    </span>/*因为Hashtable本身并不是线程同步，所以在直接创建Hasshtable对象时，它不再是线程安全的*/   
2.       private Hashtable b = Hashtable.Synchronized(new Hashtable());//线程安全的    

[html]  view plain  copy

1. <span style="white-space:pre">    </span>/*只有在创建对象时引用了线程同步，才会使得创建出来的Hashtable对象变成线程安全*/  
2.       public void IsNotSafe()    
3.       {    
4.           Console.WriteLine("是否线程安全"+a.IsSynchronized);    
5.           Console.WriteLine("是否线程安全" + b.IsSynchronized);    
6.          // table1 = Hashtable.Synchronized(a);    
7.           Console.WriteLine("是否线程安全" + a.IsSynchronized);//    
8.       }    
9.     
10.       private void WriteA()    
11.       {    
12.           lock (a.SyncRoot)    
13.           {    
14.               Console.WriteLine("go  into  WriteA");    
15.               for (int i = 0; i < 10; i++)    
16.               {    
17.                   a.Add(i, i);    
18.                   Console.WriteLine(i);    
19.                   Thread.Sleep(500);    
20.               }    
21.               Console.WriteLine("exit from  WriteA");    
22.           }    
23.       }    
24.       private void WriteB()    
25.       {    
26.           lock (table1.SyncRoot)    
27.           {    
28.               Console.WriteLine("go  into   WriteB");    
29.               for (int i = 10; i < 20; i++)    
30.               {    
31.                   table1.Add(i, i);    
32.                   Console.WriteLine(i);    
33.                   Thread.Sleep(500);    
34.               }    
35.               Console.WriteLine("exit from  WriteB");    
36.           }    
37.       }    
38.       private void ReadA()    
39.       {    
40.           lock (a.SyncRoot)    
41.           {    
42.               Console.WriteLine("go  into   ReadA");    
43.               foreach (object a in A)    
44.               {    
45.                   Console.WriteLine(a.ToString());    
46.                   Thread.Sleep(500);    
47.               }    
48.           }    
49.           Console.WriteLine("exit from  ReadA");    
50.       }    
51.       public void SyncTest2()    
52.       {    
53.           Thread tWrite1 = new Thread(WriteA);    
54.           Thread tWrite2 = new Thread(WriteB);    
55.           Thread tRead1= new Thread(ReadA);    
56.           Thread tRead2 = new Thread(ReadB);    
57.           tWrite1.Start();    
58.           tRead2.Start();    
59.           tWrite2.Start();    
60.           tRead1.Start();    
61.       }    
62.   }    

经过以上的例子，我们可以很明显的测试出，只有实现了serializable接口的Hashtable才能算作是线程安全。