c#使用多线程调用第三方c++dll 时报错

Question

c#调用第三方c++ dll 时，主画面调用dll方法，单独起一个线程同样调用dll方法，会报错 ，尝试读取或者写入受保存的内存
在不更改第三方代码的情况下，如何编写代码避免此错误，请列出对应代码，谢谢

Answer 1

此答案是由GPT4和本人亲自作答，如有帮助，还请采纳！
在 C# 中通过多线程调用第三方 C++ DLL 时，出现“尝试读取或者写入受保护的内存”的错误，通常意味着存在内存访问冲突。这种情况在并发环境下调用非线程安全的 DLL 函数时尤其常见，尤其是在 DLL 的内部使用了静态变量或全局状态的情况下。如果不能修改第三方 DLL 的代码，那么可以通过以下几种策略来避免错误的发生：

错误原因分析

C# 调用 C++ DLL，主要通过 P/Invoke 机制，跨语言的调用容易出现一些内存管理上的问题。此类错误通常由以下几种原因引起：

1. 非线程安全的 DLL：C++ DLL 内部可能使用了共享资源（如静态变量或全局变量），这些资源在多线程访问时没有适当的同步保护。
2. 多线程下的不安全操作：多个线程同时调用同一个 DLL 函数，可能导致内存冲突或其他资源竞争问题。
3. 内存管理不当：DLL 内部的内存分配和释放方式与托管代码的内存管理不同，可能导致内存保护错误。

解决方案

如果不能修改第三方 DLL 的代码，解决该问题的核心在于确保线程安全的调用。可以通过以下几种策略避免多线程下的内存冲突：

1. 使用 lock 关键字进行线程同步

最简单的解决方案是使用 C# 的 lock 关键字，在调用 DLL 方法时对其进行线程同步，确保同一时刻只有一个线程调用该方法。这样可以避免并发引发的冲突。

using System;
using System.Runtime.InteropServices;
using System.Threading;

class Program
{
    // 假设这是从 C++ DLL 导入的函数
    [DllImport("ThirdPartyLibrary.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int DllFunction();

    // 定义一个对象用于锁定调用
    private static readonly object lockObject = new object();

    public static void Main(string[] args)
    {
        // 启动多个线程调用 DLL 函数
        Thread thread1 = new Thread(CallDllFunction);
        Thread thread2 = new Thread(CallDllFunction);

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

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

        Console.WriteLine("完成调用");
    }

    public static void CallDllFunction()
    {
        // 锁定，确保每次只有一个线程能调用 DLL 方法
        lock (lockObject)
        {
            int result = DllFunction();
            Console.WriteLine($"调用结果: {result}");
        }
    }
}

在这个代码中，lock 关键字用于确保同一时间只有一个线程能够调用 DllFunction，从而避免线程之间的竞争导致的内存冲突。尽管这会牺牲一定的并发性能，但可以确保安全性。

2. 使用互斥量（Mutex）实现跨进程同步

如果你的程序中存在多个进程同时调用同一个 DLL 函数，使用 C# 的 lock 可能不足以保证同步。在这种情况下，可以使用 Mutex，它不仅可以在线程之间同步，还可以在进程之间同步。

using System;
using System.Runtime.InteropServices;
using System.Threading;

class Program
{
    [DllImport("ThirdPartyLibrary.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int DllFunction();

    // 创建一个全局的互斥体，用于跨进程同步
    private static Mutex mutex = new Mutex(false, "GlobalDllMutex");

    public static void Main(string[] args)
    {
        // 启动多个线程调用 DLL 函数
        Thread thread1 = new Thread(CallDllFunction);
        Thread thread2 = new Thread(CallDllFunction);

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

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

        Console.WriteLine("完成调用");
    }

    public static void CallDllFunction()
    {
        // 请求互斥量，确保每次只有一个线程或进程能调用 DLL 方法
        mutex.WaitOne();
        try
        {
            int result = DllFunction();
            Console.WriteLine($"调用结果: {result}");
        }
        finally
        {
            // 释放互斥量
            mutex.ReleaseMutex();
        }
    }
}

Mutex 允许跨进程同步，确保多个进程中的不同线程不会同时调用 DLL 方法。

3. 使用线程本地存储（Thread Local Storage, TLS）

如果 DLL 的方法是线程不安全的，但每个线程的调用彼此独立（没有共享状态），可以考虑使用线程本地存储（TLS），确保每个线程有独立的 DLL 实例或数据副本。C# 中的 ThreadLocal<T> 可以用于此目的。

using System;
using System.Runtime.InteropServices;
using System.Threading;

class Program
{
    [DllImport("ThirdPartyLibrary.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int DllFunction();

    // 定义线程本地变量
    private static ThreadLocal<int> threadLocalResult = new ThreadLocal<int>(() => 0);

    public static void Main(string[] args)
    {
        // 启动多个线程调用 DLL 函数
        Thread thread1 = new Thread(CallDllFunction);
        Thread thread2 = new Thread(CallDllFunction);

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

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

        Console.WriteLine("完成调用");
    }

    public static void CallDllFunction()
    {
        // 每个线程独立调用 DLL 方法，存储在该线程自己的本地变量中
        threadLocalResult.Value = DllFunction();
        Console.WriteLine($"线程 {Thread.CurrentThread.ManagedThreadId} 调用结果: {threadLocalResult.Value}");
    }
}

在这个例子中，每个线程都有自己独立的结果存储位置，避免了线程之间共享数据导致的冲突。

4. 使用任务调度器（Task Scheduler）限制并发调用

如果 DLL 方法确实需要多次调用，但你希望限制并发线程的数量，Task 并行库中的 TaskScheduler 可以帮助你控制并发调用的数量。通过设定最大并发数，避免过多线程同时调用 DLL 方法。

using System;
using System.Runtime.InteropServices;
using System.Threading.Tasks;

class Program
{
    [DllImport("ThirdPartyLibrary.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern int DllFunction();

    public static void Main(string[] args)
    {
        // 定义任务调度器，限制最大并发数为1
        var taskScheduler = new LimitedConcurrencyLevelTaskScheduler(1);
        var taskFactory = new TaskFactory(taskScheduler);

        Task[] tasks = new Task[2];

        for (int i = 0; i < 2; i++)
        {
            tasks[i] = taskFactory.StartNew(CallDllFunction);
        }

        Task.WaitAll(tasks);
        Console.WriteLine("完成调用");
    }

    public static void CallDllFunction()
    {
        int result = DllFunction();
        Console.WriteLine($"调用结果: {result}");
    }
}

// 自定义任务调度器，限制并发线程数
public class LimitedConcurrencyLevelTaskScheduler : TaskScheduler
{
    private readonly int _maxDegreeOfParallelism;
    private int _delegatesQueuedOrRunning = 0;

    public LimitedConcurrencyLevelTaskScheduler(int maxDegreeOfParallelism)
    {
        if (maxDegreeOfParallelism < 1) throw new ArgumentOutOfRangeException(nameof(maxDegreeOfParallelism));
        _maxDegreeOfParallelism = maxDegreeOfParallelism;
    }

    protected override IEnumerable<Task> GetScheduledTasks()
    {
        return null;
    }

    protected override void QueueTask(Task task)
    {
        if (Interlocked.Increment(ref _delegatesQueuedOrRunning) <= _maxDegreeOfParallelism)
        {
            ThreadPool.QueueUserWorkItem(_ => TryExecuteTask(task));
        }
        else
        {
            Interlocked.Decrement(ref _delegatesQueuedOrRunning);
        }
    }

    protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
    {
        return false;
    }
}

在这个例子中，LimitedConcurrencyLevelTaskScheduler 限制了并发调用的数量，确保不会有超过指定数量的线程同时执行任务。你可以根据需要调整并发数量。

总结

当在 C# 中使用多线程调用第三方 C++ DLL 时，遇到内存访问冲突的问题，可能的解决方法包括：

1. 使用 lock 关键字进行线程同步。
2. 使用 Mutex 进行跨进程同步。
3. 使用 ThreadLocal<T> 来实现线程本地存储，避免共享状态。
4. 使用自定义任务调度器限制并发调用的数量。

这些方法都可以在不修改第三方 DLL 代码的前提下解决多线程环境下的内存访问冲突问题。