【ET6.0】 C#多线程

于 2023-08-13 21:00:08 发布
阅读量153 收藏
点赞数 2
分类专栏： ET学习笔记 文章标签： c# 开发语言 游戏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62389241/article/details/132265170
版权

【ET6.0】C#多线程

一个简单的多线程例子

public class Program1_1
{
    public static void Main1_1()
    {
        Console.WriteLine($"main thread1 {Thread.CurrentThread.ManagedThreadId}");

        Thread thread = new Thread(_ =>
        {
            Console.WriteLine($"thread start {Thread.CurrentThread.ManagedThreadId}");
        });
        Console.WriteLine($"main thread2 {Thread.CurrentThread.ManagedThreadId}");
        thread.Start();
        thread.Join(); //等待多线程执行完成
        Console.WriteLine($"main thread3 {Thread.CurrentThread.ManagedThreadId}");
    }
}
main thread1 1
main thread2 1
thread start 4
main thread3 1

线程结果回调

假设一个需求：服务器端接收到一个寻路请求，并在寻路结束后返回结果给客户端。
因为寻路计算量大，主线程新开一个进程执行寻路逻辑，并传入一个发送消息的回调。新线程执行完寻路逻辑之后，执行主线程传入的回调。

public class Program1_2
{
    public static Object obj = new object();

    public static void Main1_2()
    {
        int a = 0;
        Console.WriteLine($"Main thread {Thread.CurrentThread.ManagedThreadId}");

        StartThread(() => { FindPath(() => { SendMsg(ref a); }); });
        StartThread(() => { FindPath(() => { SendMsg(ref a); }); });

        while (true)
        {
        }
    }

    public static void StartThread(Action action)
    {
        new Thread(_ =>
        {
            Thread.Sleep(new Random().Next(0, 10));
            action.Invoke();
        }).Start();
    }

    public static void FindPath(Action ThreadFinishCallback)
    {
        Console.WriteLine($"FindPath {Thread.CurrentThread.ManagedThreadId}");
        ThreadFinishCallback.Invoke();
    }

    public static void SendMsg(ref int a)
    {
        lock (obj)
        {
            a++;
            Thread.Sleep(10000);
        }

        Console.WriteLine($"SendMsg: {a} {Thread.CurrentThread.ManagedThreadId}");
    }
}
Main thread 1
FindPath 4
FindPath 5
SendMsg: 1 4
SendMsg: 2 5

多线程SendMsg中竞争公共资源变量a。因为有对公共资源的写入，应该对其加锁。加锁不仅性能低（并发度降低，多个线程需要互相等待才能访问共享资源。这样会增加线程的等待时间），又有可能导致死锁问题，举一个计算发生死锁的最大资源数的问题： 假设单个线程执行任务需要n个资源，此时总共有(n-1)*m个资源，m个线程。如果每个线程占有n-1个资源，并且等待其他线程释放资源，所有线程都阻塞了，这时需要系统强制释放资源或者杀掉进程才能重新运行，简直是灾难性事故。
如果多线程sendMsg可以改成单线程的就好了。即SendMsg方法统一在主线程调用，异步变同步，也不用担心数据不一致的问题。具体看下面。

跨线程操作

public class Program1_3
{
    public static void Main1_3()
    {
        int a = 0;
        ThreadSynchronizationContext.Instance.Post(()=>{Console.WriteLine($"Main thread {Thread.CurrentThread.ManagedThreadId}");});//设置主线程
        StartThread(() => { FindPath(() => { SendMsg(ref a); }); });
        StartThread(() => { FindPath(() => { SendMsg(ref a); }); });

        while (true)
        {
            Thread.Sleep(1); //避免cpu占用率太高
            ThreadSynchronizationContext.Instance.Update();
        }
    }

    public static void StartThread(Action action)
    {
        new Thread(_ => { action.Invoke(); }).Start();
    }

    public static void FindPath(Action ThreadFinishCallback)
    {
        Console.WriteLine($"FindPath {Thread.CurrentThread.ManagedThreadId}");
        ThreadSynchronizationContext.Instance.Post(ThreadFinishCallback); //将回调扔回主线程执行
    }

    public static void SendMsg(ref int a)
    {
        a++;
        Console.WriteLine($"SendMsg: {a} {Thread.CurrentThread.ManagedThreadId}");
    }
}
Main thread 1
FindPath 4
FindPath 5
SendMsg: 1 1
SendMsg: 2 1

在上面的例子中，新线程执行完寻路操作后，将SendMsg回调传入ThreadSynchronizationContext的回调队列中，并在Update中不断从队列取出回调执行，可以看到SendMsg编程在主线程执行了。
ThreadSynchronizationContext实现如下：

namespace ET
{
    public class ThreadSynchronizationContext : SynchronizationContext
    {
        //单例---主线程
        public static ThreadSynchronizationContext Instance { get; } = new ThreadSynchronizationContext(Thread.CurrentThread.ManagedThreadId);
        //主线程id
        private readonly int threadId;

        //线程同步队列，发送 接受socket回调都放回该队列，由poll线程同一执行
        private readonly ConcurrentQueue<Action> queue = new ConcurrentQueue<Action>();
        //ConCurrentQueue是一个线程安全的队列  https://learn.microsoft.com/en-us/dotnet/api/system.collections.concurrent.concurrentqueue-1?view=net-7.0
        private Action a;
        
        public ThreadSynchronizationContext(int threadId)
        {
            //传入主线程id
            this.threadId = threadId;
        }

        public void Update()
        {
            while (true)
            {
                //尝试将队列中第一个委托出队，如果成功出队，则执行委托，否则结束这一委托
                if (!this.queue.TryDequeue(out a))
                {
                    return;
                }

                try
                {
                    a();
                }
                catch (Exception e)
                { 
                    Log.Error(e);
                }
            }
        }

        public override void Post(SendOrPostCallback callback, object state)
        { 
            this.Post(()=>callback(state));
        }

        public void Post(Action action)
        {
            //如果当前线程就是主线程，那么不需要执行入队这一操作，直接执行委托
            if (Thread.CurrentThread.ManagedThreadId == this.threadId)
            {
                try
                {
                    action();
                }
                catch (Exception e)
                {
                    Log.Error(e);
                }

                return;
            }
            
            this.queue.Enqueue(action);
        }

        public void PostNext(Action action)
        {
            this.queue.Enqueue(action);
        }
    }
}

Task.Run的简单例子

注意，Task.Run是从线程池中取出一个线程（不一定新建进程，也有可能从池中取出空闲的）。

public class Program1_4
{
    public static void Main1_4()
    {
        //设置主线程
        ThreadSynchronizationContext.Instance.Post(()=>{Console.WriteLine($"Main thread {Thread.CurrentThread.ManagedThreadId}");});

        Task.Run(() =>{FindPath(SendMsg);});
        Task.Run(() =>{FindPath(SendMsg);});

        while (true)
        {
            Thread.Sleep(1);
            ThreadSynchronizationContext.Instance.Update();
        }
    }

    public static void FindPath(Action ThreadFinishCallback)
    {
        Console.WriteLine($"FindPath {Thread.CurrentThread.ManagedThreadId}");
        ThreadSynchronizationContext threadSynchronizationContext = ThreadSynchronizationContext.Instance;
        threadSynchronizationContext.Post(ThreadFinishCallback); //这里先主动回调扔回主线程执行
    }

    public static void SendMsg()
    {
        Console.WriteLine($"SendMsg: {Thread.CurrentThread.ManagedThreadId}");
    }
}

Main thread 1
FindPath 6
FindPath 4
SendMsg: 1
SendMsg: 1

await的使用

public class Program1_5
{
    public static void Main1_5()
    {
        //设置主线程
        Console.WriteLine($"Main thread {Thread.CurrentThread.ManagedThreadId}");
        
        StartTask();
        while (true)
        {
        }
    }

    public static async void StartTask()
    {
        await Task.Run(FindPath);
        SendMsg();
    }
    
    public static void FindPath()
    {
        Console.WriteLine($"FindPath {Thread.CurrentThread.ManagedThreadId}");
    }

    public static void SendMsg()
    {
        Console.WriteLine($"SendMsg: {Thread.CurrentThread.ManagedThreadId}");
    }
}

Main thread 1
FindPath 4
SendMsg: 4

同步上下文

可以看到，这个例子中的SendMsg又变成多线程的了。每次执行完异步操作都要手动同步上下文，这实在太麻烦了，有没有什么方法能让编译器帮我们搞定同步的问题呢？
我们先修改ThreadSynchronizationContext构造函数。

public ThreadSynchronizationContext(int threadId)
{
    //传入主线程id
    this.threadId = threadId;
    SynchronizationContext.SetSynchronizationContext(this); //设置要同步到当前线程。
} 

public class Program1_5
{
    public static void Main1_5()
    {
        //设置主线程
        Game.ThreadSynchronizationContext.Post(()=>{Console.WriteLine($"Main thread {Thread.CurrentThread.ManagedThreadId}");});
        StartTask();
        StartTask();
        while (true)
        {
            Thread.Sleep(1);
            Game.ThreadSynchronizationContext.Update();
        }
    }

    public static async void StartTask()
    {
        await Task.Run(FindPath);
        SendMsg();
    }
    
    public static void FindPath()
    {
        Console.WriteLine($"FindPath {Thread.CurrentThread.ManagedThreadId}");
    }

    public static void SendMsg()
    {
        Console.WriteLine($"SendMsg: {Thread.CurrentThread.ManagedThreadId}");
    }
}
Main thread 1
FindPath 4
FindPath 6
SendMsg: 1
SendMsg: 1

可以看到，此时我们并没有调用Post方法，但是SendMsg还是回到主线程了。编译器在编译之后为我们生成了一些额外的代码，也就是说实际的代码可能长下面这个样子。

public static async void StartTask()
{
    SynchronizationContext synchronizationContext = SynchronizationContext.Current;
    await Task.Run(FindPath);

    //没有同步上下文，可能送入一个新线程执行，也有可能在之前的线程上执行
    if (synchronizationContext == null)
    {
        // SendMsg();
        ThreadPool.QueueUserWorkItem((_) => { SendMsg(); });
    }
    //扔回同步上下文里
    else
    {
        synchronizationContext.Post((_) =>
        {
            SendMsg();       
        },null);
    }
}

在上面ThreadSynchronizationContext构造函数我们设置了SynchronizationContext.Current。因此会自动调用post将await之后的操作回调到主线程执行。

将回调改成await的形式

 //把一个回调转成task
public static async Task Run(Action action)
{
    TaskCompletionSource tcs = new TaskCompletionSource();
    //线程池执行任务
    ThreadPool.QueueUserWorkItem((_) =>
    {
        action.Invoke();
        Console.WriteLine($"set result: {Thread.CurrentThread.ManagedThreadId}");
        tcs.SetResult();
    });
    await tcs.Task;
}

public static async void StartTask()
{
    await Run(FindPath);
    SendMsg();
}

把Task修改成ETTask

public class Program1_6
{
    public static void Main1_6()
    {
        //设置主线程
        Game.ThreadSynchronizationContext.Post(()=>{Console.WriteLine($"Main thread {Thread.CurrentThread.ManagedThreadId}");});
        
        StartTask2().Coroutine();
        while (true)
        {
            Thread.Sleep(1);
            Game.ThreadSynchronizationContext.Update();
        }
    }

    public static async ETTask ETRun(Action action)
    {
        ETTask tcs = ETTask.Create();
        SynchronizationContext synchronizationContext = SynchronizationContext.Current;
        ThreadPool.QueueUserWorkItem((_) =>
        {
            action.Invoke();
            if (synchronizationContext == null)
            {
                Console.WriteLine($"thread finish callback:{Thread.CurrentThread.ManagedThreadId}");
                tcs.SetResult();
            }
            else
            {
                synchronizationContext.Post((_) => { tcs.SetResult();},null);
            }
        });
        await tcs;
    }
    
    public static async ETTask StartTask2()
    {
        await ETRun(FindPath);
        SendMsg();
    }

    public static void FindPath()
    {
        Console.WriteLine($"FindPath {Thread.CurrentThread.ManagedThreadId}");
    }

    public static void SendMsg()
    {
        Console.WriteLine($"SendMsg: {Thread.CurrentThread.ManagedThreadId}");
    }
}

Task.Factory.StartNew实现线程的调度。

Task本身不会执行任何代码，需要使用线程来执行Task的代码。Task.Factory.StartNew方法中可以传入一个TaskScheduler对象来调度Task。可以直接在当前线程执行task，也可以从线程池中分配线程执行。

public class Program1_7
{
    public static void Main1_7()
    {
        //设置主线程
        Game.ThreadSynchronizationContext.Post(()=>{Console.WriteLine($"Main thread {Thread.CurrentThread.ManagedThreadId}");});
        
        StartTask();
        
        while (true)
        {
            Thread.Sleep(1);
            Game.ThreadSynchronizationContext.Update();
        }
    }

    public static async void StartTask()
    {
        await Task.Factory.StartNew(FindPath, new CancellationToken(), TaskCreationOptions.None, MyTaskSchedule.Instance);
        SendMsg(); //此时依然会同步到主线程
    }

    class MyTaskSchedule : TaskScheduler
    {
        public static MyTaskSchedule Instance { get; } = new MyTaskSchedule();
        
        protected override IEnumerable<Task> GetScheduledTasks()
        {
            return null;
        }
        
        //调度task(执行StartNew时会调用此方法)
        protected override void QueueTask(Task task)
        {
            // TryExecuteTask(task); //直接在主线程执行task
            //线程池的调度
            ThreadPool.QueueUserWorkItem((_) => TryExecuteTask(task));
        }

        protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
        {
            throw new NotImplementedException();
        }
    }

    public static void FindPath()
    {
        Console.WriteLine($"FindPath {Thread.CurrentThread.ManagedThreadId}");
    }

    public static void SendMsg()
    {
        Console.WriteLine($"SendMsg: {Thread.CurrentThread.ManagedThreadId}");
    }
}

参考链接

[1] C# 异步编程TaskScheduler
[2] 网络游戏架构设计 by 熊猫

hutian2501
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#多线程的一个例子
01-05
C#多线程的一个例子 1.带参数的多线程 2.处理了UI元素的控制
C#多线程实例
03-07
C#多线程实例
c# 线程
baibu1683的博客
06-01 143
线程的本质　　线程不是一个计算机硬件的功能，而是操作系统提供的一种逻辑功能，线程本质上是进程中一段并发运行的代码，所以线程需要操作系统投入CPU资源来运行和调度。 一、多线程的优缺点、使用范围 优点:线程中的处理程序依然是顺序执行，符合普通人的思维习惯，所以编程简单； 缺点:线程的使用（滥用）会给系统带来上下文切换的额外负担。并且线程间的共享变量可能造成死锁的出现； 适用范...
C#多线程简单示例
murenxiaowei的博客
05-19 793
作为代码小白，最近需要用到C#多线程，搜了一下，得到很多前辈的指点，尤其有一个很好理解的帖子。 大致抄录如下，侵权通删！！！ #region using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using System.Threading.Tasks; #endregion namespace Multi_Threading_Exam
C#多线程简单例子
weixin_30478619的博客
07-09 284
CodeusingSystem;usingSystem.Collections.Generic;usingSystem.Linq;usingSystem.Text;usingSystem.Threading;namespacewinConsole{classProgram{staticvoidfunction(){...
基于C#的ET6.0开源项目设计源码
最新发布
05-31
ET6.0开源项目源码，共1915个文件，采用C#、Shell、C、C++和C等语言开发，涉及多种文件类型如META文件、C#源代码、文本文件、字节文件、Markdown文档、Asset文件、DLL文件、XLSX文件、ASMDEF文件、SO库文件等。...
Nice-ET：基于ET6.0的分布式游戏服务器
02-05
此项目基于ET6.0修改而来，适应客户端框架： Nice-Lua：Unity-Lua客户端框架 Nice-TS：Unity-TS客户端框架 第一次启动请先修改mongodb配置：Nice-ET / Config / StartZoneConfig.txt 自带工具： -Excel导出工具 -...
C#多线程同步与异步的实现
07-23
主要对C# 语言在1N ET 平台下进行多线程程序设计的方法进行探讨, 着重探讨了实现多线程同步与异步的步骤与方法, 并给出实现同步与异步的实例。
android中多线程下载实例
01-05
代码如下: public class MainActivity extends Activity { // 声明控件 // 路径与线程数量 private EditText et_url, et_num; // 进度条 public static ProgressBar pb_thread; // 显示进度的操作 private TextView ...
ET-6.0服务器双端框架正式版.zip
11-30
ET-6.0服务器双端框架是专门为游戏开发设计的一款高效工具，由C#语言编写的，其核心开发者是千古风流项目的主程——熊猫。这个框架的主要特点是它集成了热更新和AI框架，极大地提升了游戏开发的效率，特别是在与...
C#各种多线程使用的示例
09-03
包含了各种C#多线程使用的示例，锁的机制，多线程之间的协等等
C#多线程处理实例
06-05
多线程就是使程序并发（同时）执行几个操作。本文详细讲解例程
关于C#多线程的函数示例
05-04
用c#实现的 多线程小例子 不带参数/带参数的多线程函数示例
C#.NET多线程实例6个(包括多线程基本使用，多线程互斥等全部多线程使用实例)完整源码
02-15
C#.NET多线程实例6个(包括多线程基本使用，多线程互斥等全部多线程使用实例)完整源码
C#.NET多线程实例6个(包括多线程基本使用，多线程互斥等全部多线程使用实例)(十分经典)
03-01
C#.NET多线程实例6个(包括多线程基本使用，多线程互斥等全部多线程使用实例)(十分经典)
C#简单的多线程实例
hdhai9451的专栏
08-15 1177
多线程
C#多线程实例汇总
Dahlin哥's 博客
02-10 4498
我汇总了一下关于C#多线程的使用方法，包括一些简单的锁和线程池的常用方法，虽然古老了一些，但是在一些老的项目中还是能经常用到的，多线程和异步有点儿小区别，分两篇文章来汇总，下一篇我再总结一下关于C#异步的新旧使用方法。
C#多线程问题2_简单案例_ i++
liuxueyi521的专栏
12-17 266
  多线程资源共享问题案例： --原因不解释，学习案例。 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Threading; namespace ConsoleApplicatio...
如何用ET6.0框架创建一个游戏对象
05-23
在ET6.0框架中创建游戏对象需要先定义游戏对象的组件。ET6.0中每个组件都是一个System，需要继承ET的Component类。 示例代码如下： ```csharp // 定义游戏对象的组件 public class GameObjectComponent: Component { public string Name; // 游戏对象名称 public override void Dispose() { if (this.IsDisposed) { return; } base.Dispose(); } } // 创建游戏对象 GameObject gameObject = ETModel.GameObjectFactory.CreateWithId(id); gameObject.AddComponent<GameObjectComponent>(); ``` 在这个示例中，我们定义了一个名为GameObjectComponent的组件，用于表示游戏对象的名称。然后，我们创建一个游戏对象，并向其添加该组件。这样，我们就成功地创建了一个游戏对象。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值