Hashtable hashtable = new Hashtable(n);

var hashtable = new System.Collections.Generic.Dictionary<int, double>(n);

using System;
using System.Collections;
using System.Runtime;

namespace Hashtablebenchmark
{
    class Program
    {

        static void Main(string[] args)
        {
            int n = 10000000;
            for (int j=0; j<10; ++j) {

                var startTime = DateTime.Now; 
                Hashtable hashtable = new Hashtable(n);

                for (int i = 1; i <= n; ++i)
                    hashtable.Add(i, 1.0f / i);

                Console.WriteLine("m[100] = " + hashtable[100]);
                var endTime = DateTime.Now; 
                var time = endTime- startTime;
                Console.WriteLine("Took: " + time.TotalMilliseconds / 1e3 + "s");
            }

            Console.ReadKey();
        }
    }
}

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <startup> 
        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
    </startup>
  <runtime>
    <gcConcurrent enabled="false"/>
    <gcServer enabled="true" />
  </runtime>
</configuration>

package hashtablebenchmark;
import java.util.HashMap;

public class Hashtablebenchmark {

    public static void main(String[] args) {
        int n = 10000000;
        for (int j=0; j<10; ++j) {
            long startTime = System.currentTimeMillis();
            HashMap hashtable = new HashMap(n);
            for(int i=1; i<=n; ++i) 
                hashtable.put(i, 1.0f / i);

            System.out.println("m[100] = " + hashtable.get(100));
            long time = System.currentTimeMillis() - startTime;
            System.out.println("Took: " + time / 1e3 + "s");
        }
    }
}

If multiple threads access a hash map concurrently, and at least one of the threads modifies the map structurally, it must be synchronized externally.

        private volatile int version;
        private volatile bool isWriterInProgress;

WH>isWriterInProgress || (currentversion != version)
WH>

Accure fence гарантирует что инструкции, стоящие после барьера, не будут перемещены в позицию до барьера.

WH>        private volatile int version;
WH>        private volatile bool isWriterInProgress;
WH>

Термин volatile read означает чтение памяти в сочетании с созданием accure fence.
Accure fence гарантирует что инструкции, стоящие после барьера, не будут перемещены в позицию до барьера.

private bucket[] buckets; // без volatile
...
                bucket[] lbuckets = buckets;
                ...
                do
                {
                    int currentversion; 
                    int spinCount = 0; 
                    do {
                        // this is violate read, following memory accesses can not be moved ahead of it. 
                        currentversion = version; 
                        b = lbuckets[bucketNumber];
                        ...
                    } while ( isWriterInProgress || (currentversion != version) );

            isWriterInProgress = true;
            // Clear hash_coll field, then key, then value 
            buckets[bn].hash_coll &= unchecked((int)0x80000000); 
            if (buckets[bn].hash_coll != 0) {
                buckets[bn].key = buckets; 
            }
            else {
                buckets[bn].key = null;
            } 
            buckets[bn].val = null;  // Free object references sooner & simplify ContainsValue.
            count--; 
            UpdateVersion(); 
            isWriterInProgress = false;

M>Я не совсем точно сформулировал свой вопрос. Я хотел бы понять у сC# и шарепоинт-программистов, почему clr так легко проседает на таком простом кусочке кода по отнашению к JVM . Именно поэтому тема находится в СВ.

M>Хочу услышать их мнение .

C:\Temp>java hashtablebenchmark.Hashtablebenchmark  -Xmx3550m -Xms3550m -Xmn2g -Xss128k -XX:+UseParallelGC -XX:ParallelGCThreads=20 -XX:+UseParallelOldGC -XX:+AggressiveOpts
m[100] = 0.01
Took: 15.03s
m[100] = 0.01
Took: 14.831s
m[100] = 0.01
Took: 10.032s
m[100] = 0.01
Took: 6.485s
m[100] = 0.01
Took: 7.296s
m[100] = 0.01
Took: 6.138s
m[100] = 0.01
Took: 7.199s
m[100] = 0.01
Took: 8.847s
m[100] = 0.01
Took: 3.847s
m[100] = 0.01
Took: 5.502s

C:\Temp>"c:\Program Files\Java\jre8\bin\java.exe" hashtablebenchmark.Hashtablebenchmark  -Xmx3550m -Xms3550m -Xmn2g -Xss128k 
  -XX:+UseParallelGC -XX:ParallelGCThreads=20 -XX:+UseParallelOldGC -XX:+AggressiveOpts -server
m[100] = 0.01
Took: 14.763s
m[100] = 0.01
Took: 15.381s
m[100] = 0.01
Took: 13.893s
m[100] = 0.01
Took: 11.663s
m[100] = 0.01
Took: 8.053s
m[100] = 0.01
Took: 7.803s
m[100] = 0.01
Took: 7.746s
m[100] = 0.01
Took: 4.668s
m[100] = 0.01
Took: 3.827s
m[100] = 0.01
Took: 4.049s

C:\Temp>"c:\Program Files\Java\jre8\bin\java.exe" -version
java version "1.8.0_05"
Java(TM) SE Runtime Environment (build 1.8.0_05-b13)
Java HotSpot(TM) 64-Bit Server VM (build 25.5-b02, mixed mode)

c:\Temp>"c:\Program Files\Java\jre1.8.0_45\bin\java.exe" hashtablebenchmark.Hashtablebenchmark  -Xmx3550m -Xms3550m -Xmn
2g -Xss128k -XX:+UseParallelGC -XX:ParallelGCThreads=20 -XX:+UseParallelOldGC -XX:+AggressiveOpts -server
m[100] = 0.01
Took: 9.318s
m[100] = 0.01
Took: 3.293s
m[100] = 0.01
Took: 6.128s
m[100] = 0.01
Took: 7.477s
m[100] = 0.01
Took: 0.734s
m[100] = 0.01
Took: 0.39s
m[100] = 0.01
Took: 0.641s
m[100] = 0.01
Took: 2.588s
m[100] = 0.01
Took: 3.285s
m[100] = 0.01
Took: 2.617s

c:\Temp>"c:\Program Files\Java\jre1.8.0_45\bin\java.exe" -version
java version "1.8.0_45"
Java(TM) SE Runtime Environment (build 1.8.0_45-b15)
Java HotSpot(TM) 64-Bit Server VM (build 25.45-b02, mixed mode)

Hashtable is thread safe for use by multiple reader threads and a single writing thread. It is thread safe for multi-thread use when only one of the threads perform write (update) operations, which allows for lock-free reads provided that the writers are serialized to the Hashtable.

A Dictionary can support multiple readers concurrently, as long as the collection is not modified. Even so, enumerating through a collection is intrinsically not a thread-safe procedure. In the rare case where an enumeration contends with write accesses, the collection must be locked during the entire enumeration. To allow the collection to be accessed by multiple threads for reading and writing, you must implement your own synchronization.

isWriterInProgress || (currentversion != version)