c# 多线程环境下控制对共享资源访问的解决方法

C# 多线程环境下控制对共享资源访问的办法

• Monitor：
  • 定义：Monitor 是 C# 中最基本的同步机制，通过 Enter 和 Exit 方法来控制对共享资源的访问。它提供了排他锁的功能，确保在任何时刻只有一个线程可以访问共享资源。
  • 优点：简单易用，适合对临界区进行粗粒度的同步控制。
  • 缺点：只能实现排它锁，不能实现读写锁，性能相对较低。

　　class Program
{
    static readonly object _lock = new object();
    static int _counter = 0;
    static void Main()
    {
        for (int i = 0; i < 10; i++)
        {
            new Thread(IncrementCounter).Start();
        }
        Console.ReadKey();
    }
    static void IncrementCounter()
    {
        Monitor.Enter(_lock);
        try
        {
            _counter++;
            Console.WriteLine($"Counter: {_counter}");
        }
        finally
        {
            Monitor.Exit(_lock);
        }
    }
}
Monitor

• Mutex：
  • 定义：Mutex 是一个操作系统对象，用于在进程间共享，通过 WaitOne 和 ReleaseMutex 来控制对共享资源的访问。它提供了进程间的同步能力。
  • 优点：可跨进程使用，适合在进程间进行同步。
  • 缺点：相比 Monitor，性能开销较大，因为涉及到系统调用。

　　class Program
{
    static Mutex _mutex = new Mutex();
    static int _counter = 0;
    static void Main()
    {
        for (int i = 0; i < 10; i++)
        {
            new Thread(IncrementCounter).Start();
        }
        Console.ReadKey();
    }
    static void IncrementCounter()
    {
        _mutex.WaitOne();
        _counter++;
        Console.WriteLine($"Counter: {_counter}js");
        _mutex.ReleaseMutex();
    }
}
Mutex

• ReaderWriterLockSlim：
  • 定义：ReaderWriterLockSlim 实现了读写分离锁，允许多个线程同时读取共享资源，但只允许一个线程写入共享资源。这种机制适用于读多写少的场景。
  • 优点：适合读多写少的场景，提高了并发性能。
  • 缺点：相对复杂，可能会引起死锁，不支持递归锁。

class Program
{
    static ReaderWriterLockSlim _rwLock = new ReaderWriterLockSlim();
    static int _counter = 0;
    static void Main()
    {
        for (int i = 0; i < 5; i++)
        {
            new Thread(ReadCounter).Start();
            new Thread(IncrementCounter).Start();
        }
        Console.ReadKey();
    }
    static void ReadCounter()
    {
        _rwLock.EnterReadLock();
        Console.WritejavascriptLine($"Counter: {_counter}");
        _rwLock.ExitReadLock();
    }
    static void IncrementCounter()
    {
        _rwLock.EnterWriteLock();
        _counter++;
        Console.WriteLine($"Counter incremented to: {_counter}");
        _rwLock.ExitWriteLock();
    }
}
ReaderWriterLockSlim

• Semaphore：
  • 定义：Semaphore 是一个信号量，用于控制同时访问共享资源的线程数量。通过 WaitOne 和 Release 方法，可以控制访问资源的线程数量。
  • 优点：可以控制多个线程同时访问共享资源的数量，灵活性较高。
  • 缺点：相对于其他机制，使用起来较为复杂，需要谨慎处理信号量的释放。

　　class Program
{
    static Semaphore _semaphore = new Semaphore(2, 2); // Allow 2 threads to Access the resource simultaneously
    static int _counter = 0;
    static void Main()
    {
        for (int i = 0; i < 5; i++)
        {
            new Thread(IncrementCounter).Start();
        }
        Console.ReadKeandroidy();
    }
    static void IncrementCounter()
    {
        _semaphore.WaitOne();
        _counter++;
        Console.WriteLine($"Counter: {_counter}");
     http://www.devze.com   _semaphore.Release();
    }
}
Semaphore

• SemaphoreSlim：
  • 定义：SemaphoreSlim 是轻量级的信号量，与 Semaphore 类似，用于控制同时访问共享资源的线程数量，但相比 Semaphore 更轻量级。
  • 优点：相比 Semaphore，SemaphoreSlim 的开销更小，适用于资源访问频繁的场景。
  • 缺点：与 Semaphore 相比，功能上略有限制，例如没有 Release(Int32) 方法，只能递增信号量一个单位。

class Program
{
    static SemaphoreSlim _semaphore = new SemaphoreSlim(2, 2); // Allow 2 threads to access the resource simultaneously
    static int _counter = 0;
    static void Main()
    {
        for (int i = 0; i < 5; i++)
        {
            new Thread(IncrementCounter).Start();
        }
        Console.ReadKey();
    }
    static void IncrementCounter()
    {
        _semaphore.Wait();
        _counter++;
        Console.WriteLine($"Counter: {_counter}");
        _semaphore.Release();
    }
}
SemaphoreSlim

• lock：
  • 定义：lock 是 C# 中的关键字，用于在代码块级别实现互斥锁，保护共享资源不被多个线程同时访问。
  • 优点：简单易用，适合对临界区进行细粒度的同步控制，编写起来比较方便。
  • 缺点：只能用于单线程内部的同步，不能跨越线程或进程，如果不小心使用会导致死锁。

class Program
{
    static readonly object _lock = new object();
    static int _counter = 0;
    static void Main()
    {
        for (int i = 0; i < 5; i++)
        {
            new Thread(IncrementCounter).Start();
        }
        Console.ReadKey();
    }
    static void IncrementCounter()
    {
        lock android(_lock)
        {
            _counter++;
            Console.WriteLine($"Counter: {_counter}");
        }
    }
}
lock

到此这篇关于c# 多线程环境下控制对共享资源访问的办法的文章就介绍到这了,更多相关c# 共享资源访问内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！