C# 同步上下文与多线程？

我想优化服务器端速度和性能以管理客户端，我想我有两种方法来管理它们：

1.为每个客户端连接手动创建一个线程

2.为每个客户端创建SynchronizationContext（这将在后台管理线程）

假设我们连接了一百万用户：

第一种方法更快，但我不知道是优化还是更好的方法来管理从客户端发送/接收数据

您对提高性能和速度以无延迟和挂起地管理所有客户机有何建议

在控制台上测试SynchronizationContext和多线程的示例：

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace SynchronizationContextForMethod
{

    public class ServiceClass
    {
        public void Login(string name)
        {
            OperationContext<ClientInfo>.Current = new ClientInfo() { Name = name };
        }

        public string WhatIsMyName()
        {
            return OperationContext<ClientInfo>.Current.Name;
        }
    }

    public class ClientInfo
    {
        public string Name { get; set; }
        public string UserName { get; set; }
    }

    public class OperationContext<T>
    {
        static ConcurrentDictionary<SynchronizationContext, T> ContextByThread = new ConcurrentDictionary<SynchronizationContext, T>();
        public static T Current
        {
            get
            {
                ContextByThread.TryGetValue(SynchronizationContext.Current, out T value);
                return value;
            }
            set
            {
                ContextByThread.TryAdd(SynchronizationContext.Current, value);
            }
        }

        public static void EncContext()
        {
            ContextByThread.TryRemove(SynchronizationContext.Current, out T value);
        }
    }

    class Program
    {
        static List<SynchronizationContext> _contexts = new List<SynchronizationContext>();
        static void Main(string[] args)
        {
            ThreadPool.GetMaxThreads(out int worker, out int ports);

            ThreadPool.SetMaxThreads(int.MaxValue, int.MaxValue);
            Console.WriteLine("thread count : " + Process.GetCurrentProcess().Threads.Count);

            SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
            _contexts.Add(SynchronizationContext.Current);
            var service = new ServiceClass();

            for (int i = 0; i < 20; i++)
            {
                //PostWithNewThread((state) =>
                PostNormally((state) =>
                {
                    GC.Collect();
                    if (SynchronizationContext.Current == null)
                    {
                        SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
                    }
                    else
                    {
                        //no run ever
                    }
                    Console.WriteLine("thread count : " + Process.GetCurrentProcess().Threads.Count);
                    var name = state.ToString();
                    service.Login(name);
                    var isTrue = name == service.WhatIsMyName();
                    if (!isTrue)
                    {
                        //if false this is wrong code!
                    }
                    Console.WriteLine($"service login {name}: " + isTrue);
                    Thread.Sleep(5000);
                    Console.WriteLine($"service " + name + " finished");
                    OperationContext<ClientInfo>.EncContext();
                }, "ali" + i);
                Console.WriteLine("thread count : " + Process.GetCurrentProcess().Threads.Count);

                //PostWithNewThread((state) =>
                PostNormally((state) =>
                {
                    GC.Collect();
                    if (SynchronizationContext.Current == null)
                    {
                        SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
                    }
                    else
                    {
                        //no run ever
                    }
                    Console.WriteLine("thread count : " + Process.GetCurrentProcess().Threads.Count);
                    var name = state.ToString();
                    service.Login(name);
                    var isTrue = name == service.WhatIsMyName();
                    if (!isTrue)
                    {
                        //if false this is wrong code!
                    }
                    Console.WriteLine($"service login {name}: " + isTrue);
                    Console.WriteLine($"service " + name + " finished");
                    OperationContext<ClientInfo>.EncContext();
                }, "reza" + i);
                Console.WriteLine("thread count : " + Process.GetCurrentProcess().Threads.Count);

                //PostWithNewThread((state) =>
                PostNormally((state) =>
                {
                    GC.Collect();
                    if (SynchronizationContext.Current == null)
                    {
                        SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
                    }
                    else
                    {
                        //no run ever
                    }
                    Console.WriteLine("thread count : " + Process.GetCurrentProcess().Threads.Count);
                    Thread.Sleep(2000);
                    var name = state.ToString();
                    service.Login(name);
                    var isTrue = name == service.WhatIsMyName();
                    if (!isTrue)
                    {
                        //if false this is wrong code!
                    }
                    Console.WriteLine($"service login {name}: " + (isTrue));
                    Console.WriteLine($"service " + name + " finished");
                    OperationContext<ClientInfo>.EncContext();
                }, "hassan" + i);
            }
            Console.WriteLine("thread count : " + Process.GetCurrentProcess().Threads.Count);
            while (true)
            {
                GC.Collect();
                Thread.Sleep(1000);
                Console.WriteLine("thread count : " + Process.GetCurrentProcess().Threads.Count);
            }
        }

        public static void PostNormally(SendOrPostCallback run, object state)
        {
            SynchronizationContext.Current.Post(run, state);
        }

        public static void PostWithNewThread(SendOrPostCallback run, object state)
        {
            Thread thread = new Thread(() =>
            {
                run(state);
            });
            thread.IsBackground = true;
            thread.Start();
        }
    }
}

使用系统；
使用System.Collections.Concurrent；
使用System.Collections.Generic；
使用系统诊断；
使用System.Linq；
运用系统反思；
使用系统文本；
使用系统线程；
使用System.Threading.Tasks；
命名空间同步ContextFormMethod
{
公共类服务类
{
公共无效登录（字符串名称）
{
OperationContext.Current=new ClientInfo（）{Name=Name}；
}
公共字符串WhatIsMyName（）
{
返回OperationContext.Current.Name；
}
}
公共类ClientInfo
{
公共字符串名称{get；set；}
公共字符串用户名{get；set；}
}
公共类操作上下文
{
静态ConcurrentDictionary ContextByThread=新ConcurrentDictionary（）；
公共静态T电流
{
得到
{
TryGetValue（SynchronizationContext.Current，out T值）；
返回值；
}
设置
{
TryAdd（SynchronizationContext.Current，值）；
}
}
公共静态上下文（）
{
TryRemove（SynchronizationContext.Current，out T值）；
}
}
班级计划
{
静态列表_contexts=新列表（）；
静态void Main（字符串[]参数）
{
GetMaxThreads（out-int-worker，out-int-port）；
SetMaxThreads（int.MaxValue，int.MaxValue）；
WriteLine（“线程计数：+Process.GetCurrentProcess（）.Threads.count”）；
SetSynchronizationContext（新的SynchronizationContext（））；
_contexts.Add（SynchronizationContext.Current）；
var service=newserviceclass（）；
对于（int i=0；i<20；i++）
{
//PostWithNewThread（（状态）=>
正常情况下（（状态）=>
{
GC.Collect（）；
if（SynchronizationContext.Current==null）
{
SetSynchronizationContext（新的SynchronizationContext（））；
}
其他的
{
//永远不要跑
}
WriteLine（“线程计数：+Process.GetCurrentProcess（）.Threads.count”）；
var name=state.ToString（）；
service.Login（名称）；
var isTrue=name==service.WhatIsMyName（）；
如果（！isTrue）
{
//如果为false，这是错误的代码！
}
Console.WriteLine（$“服务登录名{name}:”+isTrue）；
睡眠（5000）；
Console.WriteLine（$“service”+name+“finished”）；
OperationContext.EncContext（）；
}“阿里”+i）；
WriteLine（“线程计数：+Process.GetCurrentProcess（）.Threads.count”）；
//PostWithNewThread（（状态）=>
正常情况下（（状态）=>
{
GC.Collect（）；
if（SynchronizationContext.Current==null）
{
SetSynchronizationContext（新的SynchronizationContext（））；
}
其他的
{
//永远不要跑
}
WriteLine（“线程计数：+Process.GetCurrentProcess（）.Threads.count”）；
var name=state.ToString（）；
service.Login（名称）；
var isTrue=name==service.WhatIsMyName（）；
如果（！isTrue）
{
//如果为false，这是错误的代码！
}
Console.WriteLine（$“服务登录名{name}:”+isTrue）；
Console.WriteLine（$“service”+name+“finished”）；
OperationContext.EncContext（）；
}，“reza”+i）；
WriteLine（“线程计数：+Process.GetCurrentProcess（）.Threads.count”）；
//PostWithNewThread（（状态）=>
正常情况下（（状态）=>
{
GC.Collect（）；
if（SynchronizationContext.Current==null）
{
SetSynchronizationContext（新的SynchronizationContext（））；
}
其他的
{
//永远不要跑
}
WriteLine（“线程计数：+Process.GetCurrentProcess（）.Threads.count”）；
《睡眠》（2000年）；
var name=state.ToString（）；
service.Login（名称）；
var isTrue=name==service.WhatIsMyName（）；
如果（！isTrue）
{
//如果为false，这是错误的代码！
}
WriteLine（$“服务登录名{name}:”+（isTrue））；
Console.WriteLine（$“服务”+名称+”finis