DotNet
자료구조
동시성 컬렉션
ConcurrentDictionary

ConcurrentDictionary

ConcurrentDictionary<TKey, TValue>는 .NET의 동시성 컬렉션 중 하나로, 멀티스레드 환경에서 안전하게 키-값 쌍을 저장하고 관리할 수 있도록 설계된 자료 구조입니다. 이 컬렉션은 Dictionary<TKey, TValue>와 비슷하지만, 여러 스레드에서 동시 접근이 가능하며, 세밀한 락fine-grained locking과 lock-free 기법을 통해 높은 성능을 제공합니다.

ConcurrentDictionary<TKey, TValue>의 특징

  • 동시성 보장: 여러 스레드가 동시에 ConcurrentDictionary에 접근하여 데이터를 읽고 수정할 수 있습니다. 내부적으로 세밀한 락fine-grained lock과 lock-free 알고리즘을 사용하여 스레드 안전성을 보장합니다.
  • 빠른 조회와 업데이트: ConcurrentDictionary는 읽기와 쓰기 작업에서 높은 성능을 제공하며, 데이터의 읽기와 업데이트 작업을 최대한 병렬로 처리할 수 있습니다.
  • 중복 키 허용 안함: ConcurrentDictionary는 고유한 키를 기반으로 데이터를 저장합니다. 동일한 키가 이미 존재할 경우, 데이터를 업데이트하거나 예외를 발생 시키는 등의 처리를 수행합니다.

주요 메서드와 사용법

  • AddOrUpdate(TKey key, Func<TKey, TValue> addValueFactory, Func<TKey, TValue, TValue> updateValueFactory): 키가 존재하지 않으면 새로운 값을 추가하고, 키가 존재하면 기존 값을 업데이트합니다.
    ConcurrentDictionary<int, string> dict = new ConcurrentDictionary<int, string>();
dict.AddOrUpdate(1, key => "Value1", (key, oldValue) => oldValue + "_Updated");
  • TryAdd(TKey key, TValue value): 지정된 키와 값을 ConcurrentDictionary에 추가합니다. 키가 이미 존재하면 false를 반환합니다.
    if (dict.TryAdd(2, "Value2"))
{
    Console.WriteLine("Key 2 added successfully.");
}
else
{
    Console.WriteLine("Key 2 already exists.");
}
  • TryRemove(TKey key, out TValue value): 지정된 키와 연결된 값을 제거하고, 제거된 값을 out 매개변수로 반환합니다. 성공하면 true를 반환합니다.
    if (dict.TryRemove(1, out string removedValue))
{
    Console.WriteLine($"Removed: {removedValue}");
}
  • TryGetValue(TKey key, out TValue value): 지정된 키와 연결된 값을 반환합니다. 키가 존재하지 않으면 false를 반환합니다.
    if (dict.TryGetValue(2, out string value))
{
    Console.WriteLine($"Value for key 2: {value}");
}
else
{
    Console.WriteLine("Key 2 not found.");
}
  • ContainsKey(TKey key): 지정된 키가 ConcurrentDictionary에 있는지 확인합니다.
    if (dict.ContainsKey(3))
{
    Console.WriteLine("Key 3 exists.");
}

ConcurrentDictionary<TKey, TValue> 사용 예시

ConcurrentDictionary<TKey, TValue>는 멀티스레드 환경에서 데이터를 안전하게 관리해야 하는 다양한 시나리오에 적합합니다. 예를 들어, 웹 서버에서 여러 요청을 동시에 처리하면서 공통 자원에 대한 접근을 관리해야 하는 경우에 사용할 수 있습니다.

using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;
class Program
{
    static void Main()
    {
        ConcurrentDictionary<int, string> dict = new ConcurrentDictionary<int, string>();
        Parallel.For(0, 10, i =>
        {
            dict.TryAdd(i, $"Value{i}");
        });
        foreach (var kvp in dict)
        {
            Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
        }
    }
}

위의 코드는 여러 스레드에서 병렬로 dict에 값을 추가하며, 각 스레드에서 데이터에 동시에 접근해도 안전하게 동작합니다.

ConcurrentDictionary<TKey, TValue>의 장단점

장점

  • 동시성: 여러 스레드에서 안전하게 데이터를 읽고 쓸 수 있습니다.
  • 고유 키 관리: 중복된 키를 허용하지 않으며, 키에 대한 데이터 관리를 쉽게 할 수 있습니다.
  • 세밀한 락 제어: 락을 최소화하여 동시성을 극대화합니다.

단점

  • 메모리 사용량: 동시성 제어를 위해 추가적인 메모리 사용이 있을 수 있습니다.
  • 복잡한 동작: 동시성 컬렉션 특성상, 일반적인 Dictionary<TKey, TValue>보다 약간 더 복잡하게 동작할 수 있습니다.

동작 원리

ConcurrentDictionary<TKey, TValue>는 내부적으로 세밀한 락fine-grained lock과 lock-free 알고리즘을 사용하여 동시성을 보장합니다. 이를 통해 여러 스레드가 동시에 데이터에 접근하더라도 안전하게 읽기, 쓰기 작업을 수행할 수 있습니다.

  • 버킷 분할: 내부적으로 데이터를 여러 개의 버킷으로 나누어 관리합니다. 각 버킷은 별도의 락을 가지고 있어, 여러 스레드가 다른 버킷에 동시에 접근할 수 있습니다. 이를 통해 락 경쟁을 최소화하고 성능을 극대화합니다.
  • 세밀한 락fine-grained lock: 세밀한 락을 사용하여 컬렉션 전체를 잠그지 않고, 필요한 버킷만 잠그기 때문에 동시성을 최대화할 수 있습니다. 예를 들어, 데이터 삽입, 삭제, 업데이트 시에도 필요한 버킷만 잠가 여러 스레드가 동시에 다른 버킷에 접근할 수 있습니다. 이렇게 하면 큰 락을 사용하는 것보다 락 경쟁이 줄어들어 성능이 향상됩니다.
  • lock-free 읽기: 읽기 작업의 경우 대부분의 상황에서 락을 사용하지 않고도 안전하게 데이터를 읽을 수 있는 구조로 설계되어 있어, 높은 성능을 유지합니다. 이는 읽기 작업 시에 락을 걸지 않고 데이터를 안전하게 읽을 수 있도록 설계된 덕분에, 읽기 작업이 많은 환경에서도 뛰어난 성능을 제공합니다.

데이터 수집 및 집계 *

다중 스레드 환경에서 데이터를 수집Data Aggregation하고 집계해야 하는 경우 ConcurrentDictionary는 각 스레드가 독립적으로 데이터를 추가하면서도, 공유된 집계 데이터에 안전하게 접근할 수 있게 해줍니다.

예제: 단어 빈도 계산기

아래는 여러 스레드가 동시에 단어를 처리하며, 단어 빈도를 계산하는 예제입니다.

using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;
public class WordFrequencyCounter
{
    private static ConcurrentDictionary<string, int> wordCounts = new ConcurrentDictionary<string, int>();
    public static void AddWord(string word)
    {
        wordCounts.AddOrUpdate(word, 1, (key, count) => count + 1);
    }
    public static void Main()
    {
        Parallel.ForEach(new[] { "apple", "banana", "apple", "cherry", "banana", "apple" },
            word => AddWord(word));
        foreach (var kvp in wordCounts)
        {
            Console.WriteLine($"{kvp.Key}: {kvp.Value}");
        }
    }
}

설명

  • AddOrUpdate 메서드를 사용하여 특정 키가 이미 존재하는 경우에는 값을 업데이트하고, 그렇지 않은 경우에는 새 키-값 쌍을 추가합니다.
  • 다중 스레드에서 동시 접근이 일어나도 안전하게 빈도 수를 집계할 수 있습니다.

캐싱과 메모이제이션

ConcurrentDictionary는 다중 스레드 환경에서 안전하게 값을 캐싱Caching하는 데 유용합니다. 계산 비용이 높은 함수의 결과를 ConcurrentDictionary에 저장하여 중복 계산을 피하는 메모이제이션Memoization을 통해 성능을 최적화할 수 있습니다.

using System;
using System.Collections.Concurrent;
public class MemoizationExample
{
    private static ConcurrentDictionary<int, long> factorialCache = new ConcurrentDictionary<int, long>();
    public static long GetFactorial(int n)
    {
        return factorialCache.GetOrAdd(n, key => CalculateFactorial(key));
    }
    private static long CalculateFactorial(int n)
    {
        if (n == 0) return 1;
        return n * CalculateFactorial(n - 1);
    }
    public static void Main()
    {
        Console.WriteLine(GetFactorial(5)); // 계산됨
        Console.WriteLine(GetFactorial(5)); // 캐시된 값 사용
    }
}
  • GetOrAdd 메서드를 통해 키가 존재하지 않을 때만 CalculateFactorial을 호출하여 계산하고, 이후에는 캐시된 결과를 재사용합니다.
  • 이는 CPU와 메모리 리소스를 절약하여 성능을 높이는 데 유용합니다.

사용자 지정 동시성 제어

때로는 특정 조건이 충족될 때만 데이터를 업데이트하고 싶을 수 있습니다. 이 경우 ConcurrentDictionary의 메서드를 조합하여 조건부 업데이트를 구현할 수 있습니다.

using System;
using System.Collections.Concurrent;
public class ConditionalUpdateExample
{
    private static ConcurrentDictionary<string, int> scores = new ConcurrentDictionary<string, int>();
    public static void UpdateScoreIfHigher(string player, int newScore)
    {
        scores.AddOrUpdate(player, newScore, (key, oldScore) =>
        {
            if (newScore > oldScore) // 특정 조건 충족 시에만 업데이트
            {
                return newScore;
            }
            return oldScore;
        });
    }
    public static void Main()
    {
        UpdateScoreIfHigher("Player1", 10);
        UpdateScoreIfHigher("Player1", 5); // 업데이트되지 않음
        UpdateScoreIfHigher("Player1", 15); // 업데이트됨
        Console.WriteLine($"Player1's score: {scores["Player1"]}");
    }
}
  • AddOrUpdate 메서드를 통해 기존 점수보다 높은 경우에만 값을 업데이트하는 조건부 업데이트를 구현합니다.
  • 이와 같은 방식으로 특정 조건이 충족될 때만 안전하게 값을 변경할 수 있습니다.

세션 관리 및 사용자 상태 저장

다수의 사용자 요청을 관리해야 하는 환경에서는 사용자별 데이터를 안전하게 저장하고 빠르게 업데이트하는 것이 중요합니다. ConcurrentDictionary를 통해 사용자 ID를 키로 사용하여 세션이나 사용자 상태 정보를 안전하게 관리할 수 있습니다.

using System;
using System.Collections.Concurrent;
public class SessionManager
{
    private static ConcurrentDictionary<string, string> userSessions = new ConcurrentDictionary<string, string>();
    public static void UpdateSession(string userId, string sessionData)
    {
        userSessions[userId] = sessionData;
    }
    public static string GetSession(string userId)
    {
        userSessions.TryGetValue(userId, out string sessionData);
        return sessionData;
    }
    public static void RemoveSession(string userId)
    {
        userSessions.TryRemove(userId, out _);
    }
}
  • 세션 데이터 업데이트: userSessions[userId] = sessionData;로 데이터를 안전하게 업데이트합니다.
  • 세션 데이터 삭제: TryRemove 메서드를 통해 특정 사용자의 세션을 안전하게 삭제할 수 있습니다.
  • 이 방식은 여러 요청이 동시 처리되는 웹 애플리케이션이나 실시간 서버에서 유용합니다.

종속성 그래프 구현

ConcurrentDictionary를 이용하여 동시성 환경에서 안전하게 종속성을 관리할 수 있습니다. 예를 들어, 그래프 구조로 저장된 종속성 간에 데이터를 추가하거나 제거할 때 ConcurrentDictionary를 활용할 수 있습니다.

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
public class DependencyGraph
{
    private ConcurrentDictionary<string, List<string>> dependencies = new ConcurrentDictionary<string, List<string>>();
    public void AddDependency(string key, string dependency)
    {
        dependencies.AddOrUpdate(key, 
            new List<string> { dependency },
            (k, list) =>
            {
                lock (list) // 리스트는 락을 사용해 안전하게 업데이트
                {
                    list.Add(dependency);
                }
                return list;
            });
    }
    public IEnumerable<string> GetDependencies(string key)
    {
        if (dependencies.TryGetValue(key, out var deps))
        {
            return deps;
        }
        return Array.Empty<string>();
    }
}
  • AddOrUpdate를 통해 새로운 키가 추가될 경우 리스트를 생성하고, 이미 존재하는 경우에는 리스트를 안전하게 업데이트합니다.
  • 리스트 자체는 스레드 안전하지 않으므로, 리스트를 업데이트할 때는 lock을 사용해 동기화합니다.

상태 머신 및 작업 흐름 관리

ConcurrentDictionary를 활용하여 여러 상태를 안전하게 관리하거나, 각 상태별로 작업을 관리하는 간단한 상태 머신을 구현할 수 있습니다.

using System;
using System.Collections.Concurrent;
public class StateMachine
{
    private static ConcurrentDictionary<string, string> itemStates = new ConcurrentDictionary<string, string>();
    public static void UpdateState(string item, string newState)
    {
        itemStates.AddOrUpdate(item, newState, (key, oldState) => newState);
    }
    public static string GetState(string item)
    {
        return itemStates.TryGetValue(item, out var state) ? state : "Unknown";
    }
    public static void Main()
    {
        UpdateState("Task1", "InProgress");
        Console.WriteLine($"Task1 State: {GetState("Task1")}");
        UpdateState("Task1", "Completed");
        Console.WriteLine($"Task1 State: {GetState("Task1")}");
    }
}
  • ConcurrentDictionary를 사용해 여러 스레드가 동시에 상태를 업데이트하거나 가져올 수 있습니다.
  • 각 항목의 상태를 업데이트하여 다중 스레드에서 안전하게 상태를 관리할 수 있습니다.
Buy me a coffee Buy me a coffee
ConcurrentBagConcurrentQueue