Hashtable.Synchronized(Hashtable) Method is used to return a synchronized (thread-safe) wrapper for the Hashtable.
Syntax:
public static System.Collections.Hashtable Synchronized (System.Collections.Hashtable table);
Here table is the Hashtable which is to be synchronized.
Return Value: This method returns a synchronized (thread-safe) wrapper for the Hashtable.
Exception: This method will throw the ArgumentNullException if the table is null.
Below programs illustrate the use of above-discussed method:
Example 1:
// C# code to get a synchronized (thread- // safe) wrapper for the Hashtable using System;
using System.Collections;
class GFG {
// Main method
static void Main( string [] args)
{
// create and initialize Hash table
// using Add() method
Hashtable has1 = new Hashtable();
has1.Add( "1" , "Welcome" );
has1.Add( "2" , "to" );
has1.Add( "3" , "geeks" );
has1.Add( "4" , "for" );
has1.Add( "5" , "geeks" );
// Creating a synchronized packing
// around the Hashtable
Hashtable has2 = Hashtable.Synchronized(has1);
// --------- Using IsSynchronized Property
// print the status of both Hashtables
Console.WriteLine( "has1 Hashtable is {0}." ,
has1.IsSynchronized ? "synchronized" :
"not synchronized" );
Console.WriteLine( "has2 Hashtable is {0}." ,
has2.IsSynchronized ? "synchronized" :
"not synchronized" );
}
} |
Output:
has1 Hashtable is not synchronized. has2 Hashtable is synchronized.
Example 2:
// C# code to get a synchronized (thread- // safe) wrapper for the Hashtable using System;
using System.Collections;
class GFG {
// Main method
static void Main( string [] args)
{
// create and initialize Hash table
// there will be no elements
Hashtable has1 = new Hashtable();
// it will give runtime error as
// table parameter can't be null
Hashtable has2 = Hashtable.Synchronized( null );
}
} |
Runtime Error:
Unhandled Exception:
System.ArgumentNullException: Value cannot be null.
Parameter name: table
Note:
- This method is a thread-safe for multiple readers and writers. Furthermore, the synchronized wrapper ensures that there is only one writer writing at a time.
- Enumerating through a collection is intrinsically not a thread-safe process. Other threads can still modify the collection, which causes the enumerator to throw an exception even when a collection is synchronized.
- To guarantee thread safety during enumeration, you can either lock the collection during the entire enumeration or catch the exceptions resulting from changes made by other threads.
- This method is an O(1) operation.
Reference: