在多線程環境下，對雙向鏈表進行并發控制是非常重要的，以確保數據的一致性和避免競爭條件。C# 提供了一些同步原語，如 Monitor、Mutex 和 Semaphore，可以用來實現對雙向鏈表的并發控制。此外，還可以使用 C# 的 lock 關鍵字來簡化同步操作。

以下是一個使用 lock 關鍵字實現并發控制的雙向鏈表示例：

public class ConcurrentDoublyLinkedList<T>
{
    private readonly object _lock = new object();
    private Node<T> _head;
    private Node<T> _tail;

    public void Add(T value)
    {
        lock (_lock)
        {
            var newNode = new Node<T>(value);

            if (_head == null)
            {
                _head = newNode;
                _tail = newNode;
            }
            else
            {
                newNode.Prev = _tail;
                _tail.Next = newNode;
                _tail = newNode;
            }
        }
    }

    public bool Remove(T value)
    {
        lock (_lock)
        {
            var current = _head;

            while (current != null)
            {
                if (current.Value.Equals(value))
                {
                    if (current.Prev != null)
                    {
                        current.Prev.Next = current.Next;
                    }
                    else
                    {
                        _head = current.Next;
                    }

                    if (current.Next != null)
                    {
                        current.Next.Prev = current.Prev;
                    }
                    else
                    {
                        _tail = current.Prev;
                    }

                    return true;
                }

                current = current.Next;
            }

            return false;
        }
    }

    private class Node<T>
    {
        public T Value { get; }
        public Node<T> Prev { get; set; }
        public Node<T> Next { get; set; }

        public Node(T value)
        {
            Value = value;
        }
    }
}

在這個示例中，我們使用了一個簡單的 Node<T> 類來表示雙向鏈表的節點。ConcurrentDoublyLinkedList<T> 類包含了一個 _lock 對象，用于在添加和刪除節點時實現同步。當一個線程正在修改鏈表時，其他線程將無法訪問鏈表，從而確保了數據的一致性。

需要注意的是，這種方法可能會導致性能瓶頸，因為在高并發場景下，線程可能會長時間等待獲取鎖。為了解決這個問題，可以考慮使用更高效的并發數據結構，如 ConcurrentQueue<T> 或 ConcurrentStack<T>，或者使用分段鎖等更復雜的同步技術。