using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace DictionariesTest
{
    class Program
    {
        private const int _itarationsCount = 8000000;

        static void Main(string[] args)
        {
            Dictionary<int, string> dictionary = new Dictionary<int, string>();

            Console.WriteLine("Testing Dictionary in single thread...");
            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();
            for (int i = 0; i < 8000000; i++)
            {
                dictionary.Add(i, i.ToString());
            }
            stopwatch.Stop();
            Console.WriteLine("Add: {0}", stopwatch.ElapsedMilliseconds);


            stopwatch.Reset();
            stopwatch.Start();
            for (int i = 0; i < 8000000; i++)
            {
                string s = dictionary[i];
            }
            stopwatch.Stop();
            Console.WriteLine("Get: {0}", stopwatch.ElapsedMilliseconds);
            Console.WriteLine(string.Empty);

            runConcurrentDictionaryTest(1);
            runConcurrentDictionaryTest(2);
            runConcurrentDictionaryTest(4);
            runConcurrentDictionaryTest(8);
            runConcurrentDictionaryTest(16);

            Console.ReadLine();
        }

        private static void runConcurrentDictionaryTest(int threadsCount)
        {
            ConcurrentDictionary<int, string> concurrentDictionary = new ConcurrentDictionary<int, string>();

            Console.WriteLine("Testing ConcurrentDictionary in {0} parallel treads...", threadsCount);

            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();
            runInMultileThreads(threadsCount, i => concurrentDictionary.TryAdd(i, i.ToString()));
            stopwatch.Stop();
            Console.WriteLine("Add: {0}", stopwatch.ElapsedMilliseconds);

            stopwatch.Reset();
            stopwatch.Start();
            runInMultileThreads(threadsCount, i => {string result = concurrentDictionary[i];});
            stopwatch.Stop();
            Console.WriteLine("Get: {0}", stopwatch.ElapsedMilliseconds);

            Console.WriteLine(string.Empty);
        }

        private static void runInMultileThreads(int threadsCount, Action<int> iterationAction)
        {
            Thread[] threads = new Thread[threadsCount];
            int step = _itarationsCount / threadsCount;

            for (int threadNumber = 1; threadNumber <= threadsCount; threadNumber++)
            {
                int min = 1 + step * (threadNumber - 1);
                int max = step * threadNumber;
                Thread thread = new Thread(() =>
                {
                    for (int i = min; i <= max; i++)
                    {
                        iterationAction(i);
                    }
                });
                threads[threadNumber - 1] = thread;
            }

            foreach (Thread thread in threads)
            {
                thread.Start();
            }


            foreach (Thread thread in threads)
            {
                thread.Join();
            }

        }
    }
}

Testing Dictionary in single thread...
Add: 1959
Get: 103

Testing ConcurrentDictionary in 1 parallel treads...
Add: 5201
Get: 195

Testing ConcurrentDictionary in 2 parallel treads...
Add: 3787
Get: 102

Testing ConcurrentDictionary in 4 parallel treads...
Add: 4780
Get: 88

Testing ConcurrentDictionary in 8 parallel treads...
Add: 3425
Get: 70

Testing ConcurrentDictionary in 16 parallel treads...
Add: 5066
Get: 65

Testing Dictionary in single thread...
Dictionary Add: 2606
Dictionary Get: 150

Testing ConcurrentDictionary in 1 parralel treads...
Add: 6448
Get: 359

Testing ConcurrentDictionary in 2 parallel treads...
Add: 4794
Get: 188

Testing ConcurrentDictionary in 4 parallel treads...
Add: 5239
Get: 279

Testing ConcurrentDictionary in 8 parallel treads...
Add: 6029
Get: 207

Testing ConcurrentDictionary in 16 parallel treads...
Add: 6500
Get: 294

lock (dictionary)
{
    dictionary.Add(key, value);
}

concurrentDictionary.TryAdd(key, value);

lock (locker)
{
    dictionary1.Add(key1, value1);
    dictionary2.Add(key2, value2);
    dictionary3.Add(key3, value3);
    dictionary4.Add(key4, value4);
    dictionary5.Add(key5, value5);
    dictionary6.Add(key6, value6);
    dictionary7.Add(key7, value7);
    dictionary8.Add(key8, value8);
    ...
}

concurrentDictionary1.TryAdd(key1, value1);
concurrentDictionary2.TryAdd(key2, value2);
concurrentDictionary3.TryAdd(key3, value3);
concurrentDictionary4.TryAdd(key4, value4);
concurrentDictionary5.TryAdd(key5, value5);
concurrentDictionary6.TryAdd(key6, value6);
concurrentDictionary7.TryAdd(key7, value7);
concurrentDictionary8.TryAdd(key8, value8);
...

    private void AcquireLocks(int fromInclusive, int toExclusive, ref int locksAcquired)
    {
      object[] objArray = this.m_tables.m_locks;
      for (int index = fromInclusive; index < toExclusive; ++index)
      {
        bool lockTaken = false;
        try
        {
          Monitor.Enter(objArray[index], ref lockTaken);
        }
        finally
        {
          if (lockTaken)
            ++locksAcquired;
        }
      }
    }

private object _syncObject = new object();

Monitor.Enter(_syncObject)

private ReadWriteLock _exclusiveReadWriteLock;

It has no side effects. The function does not change any variables or the data of any type outside of the function.

Represents a thread-safe collection of key/value pairs that can be accessed by multiple threads concurrently.

Нэш сумел разглядеть новое лицо конкуренции, смоделировав ситуацию, впоследствии получившую название «равновесие по Нэшу» или «некооперативное равновесие», при которой обе стороны используют идеальную стратегию, что и приводит к созданию устойчивого равновесия

lock( _dictinonarySyncObject )
{
   dict[name] = value;
}

int Foo()
{
    if (меня вызвала функция A)
    {
        Вычисляю результат способом 1;
    }
    else
    {
        Вычисляю результат способом 2;
    }         
}

int Foo()
{
    if (общедоступная_переменная == "А")
    {
        Вычисляю результат способом 1;
    }
    else
    {
        Вычисляю результат способом 2;
    }         
}

void Foo()
{
    общедоступная_переменная = "B";        
}

int Foo(int arg)
{
    return общедоступная_переменная * arg;
}

общедоступная_переменная = 1;
результат1 = Foo(3);
общедоступная_переменная = 3;
результат2 = Foo(3);

А>lock( _dictinonarySyncObject )
А>{
А>   dict[name] = value;
А>}

А>

lock(dict)
{
   dict[name] = value;
}

IB>    if (меня вызвала функция A)
IB>

IB>    if (общедоступная_переменная == "А")
IB>

IB>Это будет справедливо если я попытаюсь 2 операции: умножение и sin выполнить параллельно. Только я так делать не буду. Я же писал что все нужно распараллерировать "до яиц"

string Quote(string v)
{
   return (GlobalFlag == 0)
      ? "\"" + v + "\""
      : String.Format("\"{0}\"", v);
}

S>По вашему последнему дополнению к понятию общедоступной переменной — это общедоступный результат

S>string Quote(string v)
S>{
S>   return (GlobalFlag == 0)
S>      ? "\"" + v + "\""
S>      : String.Format("\"{0}\"", v);
S>}
S>

string Quote(string v)
{
   return (GlobalFlag == GlobalFlag)
      ? "\"" + v + "\""
      : String.Format("\"{0}\"", v);
}

S>Раз так, то и вызов функции — тоже goto.

public bool GetValue(TKey key, out TValue value)
 {
 int hashcode=this.m_comparer.GetHashCode(key);
 int bucketNo = (hashcode & 0x7fffffff) % 101;

СтруктураХраненияХэшТаблиц Структура=ХэшТаблицы[bucketNo];

Структура.rwl.AcquireReaderLock(0);
 try
 {
 return Структура.ХэшТаблица.GetValue(TKey key, out TValue value)

 } 
 finally
 {
 // Ensure that the lock is released.
Структура.rwl.ReleaseReaderLock();
 }


 }

private bool TryAddInternal(TKey key, TValue value, bool updateIfExists, bool acquireLock, out TValue resultingValue)
{
    int num2;
    int num3;
    Tables<TKey, TValue> tables;
    int hashCode = this.m_comparer.GetHashCode(key);
Label_000D:
    tables = this.m_tables;
    this.GetBucketAndLockNo(hashCode, out num2, out num3, tables.m_buckets.Length, tables.m_locks.Length);
    bool flag = false;
    bool lockTaken = false;
    try
    {
        if (acquireLock)
        {
            Monitor.Enter(tables.m_locks[num3], ref lockTaken);
        }
        if (tables != this.m_tables)
        {
            goto Label_000D;
        }
        Node<TKey, TValue> node = null;
        for (Node<TKey, TValue> node2 = tables.m_buckets[num2]; node2 != null; node2 = node2.m_next)
        {
            if (this.m_comparer.Equals(node2.m_key, key))
            {
                if (updateIfExists)
                {
                    if (ConcurrentDictionary<TKey, TValue>.s_isValueWriteAtomic)
                    {
                        node2.m_value = value;
                    }
                    else
                    {
                        Node<TKey, TValue> node3 = new Node<TKey, TValue>(node2.m_key, value, hashCode, node2.m_next);
                        if (node == null)
                        {
                            tables.m_buckets[num2] = node3;
                        }
                        else
                        {
                            node.m_next = node3;
                        }
                    }
                    resultingValue = value;
                }
                else
                {
                    resultingValue = node2.m_value;
                }
                return false;
            }
            node = node2;
        }
        Volatile.Write<Node<TKey, TValue>>(ref tables.m_buckets[num2], new Node<TKey, TValue>(key, value, hashCode, tables.m_buckets[num2]));
        tables.m_countPerLock[num3] += 1;
        if (tables.m_countPerLock[num3] > this.m_budget)
        {
            flag = true;
        }
    }
    finally
    {
        if (lockTaken)
        {
            Monitor.Exit(tables.m_locks[num3]);
        }
    }
    if (flag)
    {
        this.GrowTable(tables);
    }
    resultingValue = value;
    return true;
}

А детерминированность это отсутствие чтения из внешнего контекста.

private class Node
{
    // Fields
    internal int m_hashcode;
    internal TKey m_key;
    internal volatile ConcurrentDictionary<TKey, TValue>.Node m_next;
    internal TValue m_value;

    // Methods
    internal Node(TKey key, TValue value, int hashcode, ConcurrentDictionary<TKey, TValue>.Node next);
}

private struct Entry
{
    public int hashCode;
    public int next;
    public TKey key;
    public TValue value;
}

Задача определения того, является ли частично рекурсивная функция с данным описанием общерекурсивной или нет, алгоритмически неразрешима.