C#实现线程回调的示例代码_Asp.net

在 c# 中，线程回调是一种常见的编程模式，用于在线程完成任务后执行某些操作。通过使用 thread 类或其他更高层次的并发工具（如 task），可以实现线程回调的功能。

回调机制

特点

直接性：回调通常是通过委托（delegate）直接调用的，逻辑简单且明确。
单一目标：回调一般只针对一个特定的目标方法。
轻量级：由于没有额外的中间层（如事件订阅管理），回调的开销较小。

性能分析

调用开销：回调本质上是一个方法调用，性能开销非常低，几乎等同于普通方法调用。
内存分配：通常不会涉及额外的内存分配，除非需要创建闭包或匿名方法。
适用场景：
- 单一任务完成后的通知。
- 不需要解耦调用方和被调用方的场景。

性能优势

更快的执行速度，因为没有事件订阅和分发的开销。
更少的内存使用，避免了事件管理相关的额外开销。

事件机制

特点

广播性：事件可以支持多个订阅者（多播委托），适合一对多的通知场景。
解耦性：事件将发布者和订阅者解耦，适合复杂系统中的模块化设计。
灵活性：可以通过动态添加或移除事件处理器来改变行为。

性能分析

调用开销：
- 如果只有一个订阅者，事件的性能与回调类似。
- 如果有多个订阅者，事件需要遍历所有订阅者并逐一调用其处理方法，这会增加开销。
内存分配：
- 事件机制需要维护订阅者的列表，可能会导致额外的内存分配。
- 如果订阅者频繁地添加或移除，可能会引发垃圾回收的压力。
线程安全：
- 在多线程环境中，事件的订阅和触发可能需要加锁或其他同步机制，进一步增加开销。

性能劣势

多播委托的遍历会导致性能下降，尤其是在订阅者数量较多的情况下。
额外的内存分配和垃圾回收压力可能会影响性能。

性能对比总结

特性	回调	事件
调用开销	低（直接调用方法）	较高（可能需要遍历多个订阅者）
内存分配	少（通常无额外分配）	较多（需要维护订阅者列表）
适用场景	单一任务完成后的通知	一对多的通知，模块化设计
线程安全性	简单（通常无需额外同步）	复杂（可能需要加锁）
扩展性	较差（只能通知单一目标）	较好（支持动态添加/移除订阅者）

以下是实现线程回调的几种方法：

使用thread类和委托

本文介绍了如何在c#中创建和管理线程以实现并发执行，包括基本步骤、lambda表达式简化、线程间通信、数据共享与同步，以及apartmentstate在多线程和com交互中的作用。

using system;
using system.threading;

class program
{
    // 定义一个委托，用于回调
    public delegate void callbackdelegate(string message);

    static void main(string[] args)
    {
        // 创建线程并传递回调方法
        thread thread = new thread(() => dowork("线程任务完成！", callback));
        thread.start();

        console.writeline("主线程继续运行...");
        thread.join(); // 等待线程完成
    }

    // 模拟线程执行的任务
    static void dowork(string message, callbackdelegate callback)
    {
        console.writeline("线程正在执行任务...");
        thread.sleep(2000); // 模拟耗时操作
        callback?.invoke(message); // 调用回调函数
    }

    // 回调方法
    static void callback(string message)
    {
        console.writeline($"回调执行: {message}");
    }
}

输出：

主线程继续运行...
线程正在执行任务...
回调执行: 线程任务完成！

使用task和continuewith

c# 提供了更高层次的并发工具 task，可以通过 continuewith 实现线程回调。

using system;
using system.threading.tasks;

class program
{
    static void main(string[] args)
    {
        // 创建任务
        task task = task.run(() =>
        {
            console.writeline("任务正在执行...");
            thread.sleep(2000); // 模拟耗时操作
        });

        // 使用 continuewith 实现回调
        task.continuewith(t =>
        {
            console.writeline("回调执行: 任务已完成！");
        });

        console.writeline("主线程继续运行...");
        task.wait(); // 等待任务完成
    }
}

输出：

主线程继续运行...
任务正在执行...
回调执行: 任务已完成！

使用async/await和回调

结合 async/await 可以更优雅地处理异步操作，并在任务完成后执行回调。

using system;
using system.threading.tasks;

class program
{
    static async task main(string[] args)
    {
        console.writeline("主线程继续运行...");

        // 执行异步任务
        await doworkasync();

        // 回调逻辑
        callback();
    }

    static async task doworkasync()
    {
        console.writeline("任务正在执行...");
        await task.delay(2000); // 模拟耗时操作
    }

    static void callback()
    {
        console.writeline("回调执行: 任务已完成！");
    }
}

输出：

主线程继续运行...
任务正在执行...
回调执行: 任务已完成！

使用事件机制

通过定义事件和事件处理器，也可以实现线程完成后的回调。

using system;
using system.threading;

class program
{
    // 定义事件
    public static event action<string> ontaskcompleted;

    static void main(string[] args)
    {
        // 订阅事件
        ontaskcompleted += callback;

        // 启动线程
        thread thread = new thread(() => dowork("线程任务完成！"));
        thread.start();

        console.writeline("主线程继续运行...");
        thread.join(); // 等待线程完成
    }

    static void dowork(string message)
    {
        console.writeline("线程正在执行任务...");
        thread.sleep(2000); // 模拟耗时操作
        ontaskcompleted?.invoke(message); // 触发事件
    }

    static void callback(string message)
    {
        console.writeline($"回调执行: {message}");
    }
}

输出：