C# 线程锁使用

在 C# 中，线程锁的使用场景与 C++ 类似，用于控制多个线程对共享资源的并发访问，以防止数据竞争和保证数据的一致性。下面是一些线程锁的使用场景、优缺点以及例子：

使用场景

1. 共享资源的访问控制： 当多个线程需要访问共享资源时，可以使用线程锁来确保在任何时刻只有一个线程可以访问该资源，避免数据竞争和不确定的结果。
2. 临界区保护： 在需要保护临界区以避免并发访问的情况下，线程锁可以用来确保只有一个线程可以在任何时刻执行临界区的代码。
3. 线程同步： 在多线程的程序中，线程锁可以用来实现线程之间的同步，以控制线程的执行顺序和交互。

优点

1. 避免数据竞争： 线程锁可以有效避免多线程对共享资源的不同步访问，确保数据的一致性。
2. 简单易用： C# 中的锁机制（lock 关键字）使用方便，可以直接在代码中使用，而不需要显式地声明和操作锁对象。

缺点

1. 性能开销： 锁可能引入一定的性能开销，特别是在高并发的情况下，会影响系统的性能。
2. 死锁风险： 如果不正确地使用线程锁，可能会导致死锁的风险，造成程序无法继续执行。

示例1：多线程共享资源写入

using System;
using System.Threading;

class Program
{
    static object lockObj = new object();
    static int sharedValue = 0;

    static void WriteSharedValue()
    {
        lock (lockObj)
        {
            sharedValue++;
            Console.WriteLine($"Shared value is updated: {sharedValue}");
        }
    }

    static void Main()
    {
        Thread thread1 = new Thread(WriteSharedValue);
        Thread thread2 = new Thread(WriteSharedValue);

        thread1.Start();
        thread2.Start();

        thread1.Join();
        thread2.Join();
    }
}

示例2：生产者消费者模型

using System;
using System.Collections.Generic;
using System.Threading;

class Program
{
    static object lockObj = new object();
    static Queue<int> buffer = new Queue<int>();

    static void Producer()
    {
        for (int i = 0; i < 5; i++)
        {
            lock (lockObj)
            {
                buffer.Enqueue(i);
                Console.WriteLine($"Produced: {i}");
            }
            Thread.Sleep(100);
        }
    }

    static void Consumer()
    {
        for (int i = 0; i < 5; i++)
        {
            lock (lockObj)
            {
                if (buffer.Count > 0)
                {
                    int item = buffer.Dequeue();
                    Console.WriteLine($"Consumed: {item}");
                }
            }
            Thread.Sleep(100);
        }
    }

    static void Main()
    {
        Thread producerThread = new Thread(Producer);
        Thread consumerThread = new Thread(Consumer);

        producerThread.Start();
        consumerThread.Start();

        producerThread.Join();
        consumerThread.Join();
    }
}

在这些示例中，通过使用 lock 关键字锁定一个对象，实现对共享资源的访问控制，确保在任何时刻只有一个线程可以访问共享资源。这样可以避免数据竞争，保证线程安全的并发访问。