C# socket编程实践

C# socket编程实践——支持广播的简单socket服务器

 

在上篇博客简单理解socket写完之后我就希望写出一个websocket的服务器了，但是一路困难重重，还是从基础开始吧，先搞定C# socket编程基本知识，写一个支持广播的简单server/client交互demo，然后再拓展为websocket服务器。想要搞定这个需要一些基本知识

线程与进程

进程与线程对CS的同学来说肯定耳闻能像了，再啰嗦两句我个人的理解，每个运行在系统上的程序都是一个进程，进程就是正在执行的程序，把编译好的指令放入特定一块内存，顺序执行，这就是一个进程，我们平时写的if-else，for循环都按照我们预期，一步步顺序执行，这是因为我们写的是单线程的程序，所谓线程是一个进程的执行片段，我们写的单线程程序，整个进程就一个主线程，所有代码在这个线程内顺序执行，但一个进程可以有多个线程同时执行，这就是多线程程序，利用多线程支持我们可以让程序一边监听客户端请求，一边广播消息。

同步与异步

熟悉web开发的同学肯定了解这个概念，在使用ajax中我们就会用到异步的请求，同步与异步正好和我们生活中的理解相反（我尝试问过学管理的女朋友）

同步：下一个调用在上一个调用返回结果后执行，也可以理解为事情必须一件做完再去做另一件，我们经常编写的语句都是同步调用

int a=dosomething();
a+=1;

a+=1; 这条指令必须在dosomething()方法执行完毕返回结果后才可以执行，否则就乱了套

异步：异步概念和同步相对，当一个异步过程调用发出后，调用者不能立刻得到结果。实际处理这个调用的部件在完成后，通过状态、通知和回调来通知调用者（百度上抄的）。理解了同步概念后异步也就不难理解了，以javascript的ajax为例

ajax(arg1,arg2,function(){
    //回调函数
　　a=3；
});
a=4；

这个代码段执行完成后一般情况会把a赋值为3而不是4，因为在ajax方法调用后，a=4;这条语句并没有等待ajax()返回结果就执行了，也就是在ajax()执行完成调用回调函数之前，a=4；已经执行了，回调函数再把a赋值为3使之成为最后结果，为此在ajax调用中我们经常会使用回调函数，其实在很多异步处理中我们都会使用到回调函数。

阻塞

阻塞操作是指，在执行设备操作时，若不能获得资源，则进程挂起直到满足可操作的条件再进行操作。

步骤

了解了上面知识我们就可以按照下图来写我们的服务器了

整体结构

关于怎么具体一步步使用socket我就不说了，有兴趣同学可以看看你得学会并且学得会的Socket编程基础知识，看看我们服务器的结构，我写了一个TcpHelper类来处理服务器操作

首先定义 一个ClientInfo类存放Client信息

 

然后是一个SocketMessage类，记录客户端发来的消息

 

然后定义两个全局变量记录所有客户端及所有客户端发来的消息

private Dictionary<Socket, ClientInfo> clientPool = new Dictionary<Socket, ClientInfo>();
private List<SocketMessage> msgPool = new List<SocketMessage>();

然后就是几个主要方法的定义

        /// <summary>
        /// 启动服务器，监听客户端请求
        /// </summary>
        /// <param name="port">服务器端进程口号</param>
        public void Run(int port);

/// <summary>
        /// 在独立线程中不停地向所有客户端广播消息
        /// </summary>
        private void Broadcast();

/// <summary>
        /// 把客户端消息打包处理（拼接上谁什么时候发的什么消息）
        /// </summary>
        /// <returns>The message.</returns>
        /// <param name="sm">Sm.</param>
        private byte[] PackageMessage(SocketMessage sm);

/// <summary>
        /// 处理客户端连接请求,成功后把客户端加入到clientPool
        /// </summary>
        /// <param name="result">Result.</param>
        private void Accept(IAsyncResult result);

/// <summary>
        /// 处理客户端发送的消息，接收成功后加入到msgPool，等待广播
        /// </summary>
        /// <param name="result">Result.</param>
        private void Recieve(IAsyncResult result);

逐个分析一下把

void run(int port)

这是该类唯一提供的共有方法，供外界调用，来根据port参数创建一个socket

public void Run(int port)
        {
            Thread serverSocketThraed = new Thread(() =>
            {
                Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                server.Bind(new IPEndPoint(IPAddress.Any, port));
                server.Listen(10);
                server.BeginAccept(new AsyncCallback(Accept), server);
            });

            serverSocketThraed.Start();
            Console.WriteLine("Server is ready");
            Broadcast();
        }

代码很简单，需要注意的有几点

1.在一个新线程中创建服务器socket，最多允许10个客户端连接。

2.在方法最后调用Broadcast()方法用于向所有客户端广播消息

3.BeginAccept方法，MSDN上有权威解释，但是觉得不够接地气，简单说一下我的理解，首先这个方法是异步的，用于服务器接受一个客户端的连接，第一个参数实际上是回调函数，在C#中使用委托，在回调函数中通过调用EndAccept就可以获得尝试连接的客户端socket，第二个参数是包含请求state的对象，传入server socket对象本身就可以了

void Accept(IAsyncResult result)

方法用于处理客户端连接请求

private void Accept(IAsyncResult result)
        {
            Socket server = result.AsyncState as Socket;
            Socket client = server.EndAccept(result);
            try
            {
                //处理下一个客户端连接
                server.BeginAccept(new AsyncCallback(Accept), server);
                byte[] buffer = new byte[1024];
                //接收客户端消息
                client.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(Recieve), client);
                ClientInfo info = new ClientInfo();
                info.Id = client.RemoteEndPoint;
                info.handle = client.Handle;
                info.buffer = buffer;
                //把客户端存入clientPool
                this.clientPool.Add(client, info);
                Console.WriteLine(string.Format("Client {0} connected", client.RemoteEndPoint));
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error :\r\n\t" + ex.ToString());
            }
        }

BeginRecieve方法的MSDN有解释，和Accept一样也是异步处理，接收客户端消息，放入第一个参数中，它也传入了一个回调函数的委托，和带有socket state的对象，用于处理下一次接收。我们把接收成功地客户端socket及其对应信息存放到clientPool中

void Recieve(IAsyncResult result)

方法用于接收客户端消息，并把所有消息及其发送者信息存入msgInfo，等待广播

private void Recieve(IAsyncResult result)
        {
            Socket client = result.AsyncState as Socket;

            if (client == null || !clientPool.ContainsKey(client))
            {
                return;
            }

            try
            {
                int length = client.EndReceive(result);
                byte[] buffer = clientPool[client].buffer;

                //接收消息
                client.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(Recieve), client);
                string msg = Encoding.UTF8.GetString(buffer, 0, length);
                SocketMessage sm = new SocketMessage();
                sm.Client = clientPool[client];
                sm.Time = DateTime.Now;

                Regex reg = new Regex(@"{<(.*?)>}");
                Match m = reg.Match(msg);
                if (m.Value != "") //处理客户端传来的用户名
                {
                    clientPool[client].NickName = Regex.Replace(m.Value, @"{<(.*?)>}", "$1");
                    sm.isLogin = true;
                    sm.Message = "login!";
                    Console.WriteLine("{0} login @ {1}", client.RemoteEndPoint,DateTime.Now);
                }
                else //处理客户端传来的普通消息
                {
                    sm.isLogin = false;
                    sm.Message = msg;
                    Console.WriteLine("{0} @ {1}\r\n    {2}", client.RemoteEndPoint,DateTime.Now,msg);
                }
                msgPool.Add(sm);
            }
            catch
            {
                //把客户端标记为关闭，并在clientPool中清除
                client.Disconnect(true);
                Console.WriteLine("Client {0} disconnet", clientPool[client].Name);
                clientPool.Remove(client);
            }
        }

这个的代码都很简单，就不多解释了，我加入了用户名处理用于广播客户端消息的时候显示客户端自定义的昵称而不是生硬的ip地址+端口号，当然这里需要客户端配合

Broadcast()

服务器已经和客户端连接成功，并且接收到了客户端消息，我们就可以看看该怎么广播消息了，Broadcast()方法已经在run()方法内调用，看看它是怎么运作广播客户端消息的

private void Broadcast()
        {
            Thread broadcast = new Thread(() =>
            {
                while (true)
                {
                    if (msgPool.Count > 0)
                    {
                        byte[] msg = PackageMessage(msgPool[0]);
                        foreach (KeyValuePair<Socket, ClientInfo> cs in clientPool)
                        {
                            Socket client = cs.Key;
                            if (client.Connected)
                            {
                                client.Send(msg, msg.Length, SocketFlags.None);
                            }
                        }
                        msgPool.RemoveAt(0);
                    }
                }
            });

            broadcast.Start();
        }

Broadcast()方法启用了一个新线程，循环检测msgPool是否为空，当不为空的时候遍历所有客户端，调用send方法发送msgPool里面的第一条消息，然后清除该消息继续检测，直到消息广播完，其实这就是一个阉割版的观察者模式 ，顺便看一下打包数据方法

private byte[] PackageMessage(SocketMessage sm)
        {
            StringBuilder packagedMsg = new StringBuilder();
            if (!sm.isLogin) //消息是login信息
            {
                packagedMsg.AppendFormat("{0} @ {1}:\r\n    ", sm.Client.Name, sm.Time.ToShortTimeString());
                packagedMsg.Append(sm.Message);
            }
            else //处理普通消息
            {
                packagedMsg.AppendFormat("{0} login @ {1}", sm.Client.Name, sm.Time.ToShortTimeString());
            }

            return Encoding.UTF8.GetBytes(packagedMsg.ToString());
        }

如何使用

static void Main(string[] args)
        {
            TcpHelper helper = new TcpHelper();
            helper.Run(8080);
        }

这样我们就启用了server，看看简单的客户端实现，原理类似，不再分析了

 

有图有真相

这样一个简单的支持广播地socket就完成了，我们可以进行多个客户端聊天了，看看运行效果吧

最后

其实socket编程没有一开始我想象的那么难，重要的还是搞明白原理，接下来事情就迎刃而解了，这个简单的server还有不少待完善之处，主要是展示一下C# socket编程基本使用，为下一步做websocket server做准备，实习两者很相似，只是websocket server 添加了协议处理部分，这两天会尽快分享出来

感兴趣的同学可以看看源码 （注释是我写博客的时候加上的，源码中没有，不管看过博客的人应该没问题）

人魔七七 IOS专栏

IOS 专栏 QQ群：124525793

IOS多线程之线程属性的配置

 

版权声明：原创作品，谢绝转载！否则将追究法律责任。

 

设置线程堆栈的大小：

系统为每个你新创建的线程，都会为你的进程空间分配一定的内存作为该线程的堆栈。这里面有我们局部变量声明我们的方法就是一个堆栈。

 

如果你想改变一个给定线程的堆栈大小，你必须在创建该线程之前做一些操作。几乎所有线程技术都提供了相应的方法来设置堆栈的大小。

 

例如NSThread设置堆栈大小：

在IOS和MAC OS 10.5之后，创建初始化一个NSThread最好不要用雷类方法创建（detachNewThreadSelector:toTarget:withObject: ），因为我们要设置线程的堆栈大小，我们调用start方法之前用setStackSize：方法来设置。

 

设置线程并存储一些信息：
我们如果想让线程存储这个线特有的信息以便在方面的时候用到他并且可以在线程之间传递信息。比如我们之前说过的run loop处理事件。可以存储处理了多少次事件的次数。

NSThread的threadDictionary方法返回一个NSMutableDictionary对象。我们可以在里面存储线程的一些信息。

 

线程的脱离状态：

有时候我们中断一个线程时候希望回收他的资源，脱离线程可以做到。与之相反的是可连接线程，他必须在推出之前必须被其他线程连接，并且可以拿到退出线程的数据。

大部分的上层线程技术默认是创建脱离线程。因为他们在线程完成时候立刻释放回收资源。

注意：当线程处于周期性工作而不被中断的时候比如保存数据到硬盘，可连接线程是最佳选择。

 

设置线程的优先级：

试想这样一个情况一个线程池里面有很多的线程。每个线程被创建的时候等级是一样的。我们假如想让某个线程先被执行可以设置这个线程的优先级高于其他线程，这样他会被先执行。

NSThread可以setThreadPriority方法设置当前运行线程的优先级

 

设置自动释放池：

之前我们说过在线程执行的一个方法里面可以设置run loop来处理事件并且可以用一个自动释放池来清理线程代码执行后的东西。

 

IOS在他们的每个线程必须创建至少一个自动释放池。主线程默认就创建了。有自动回收机制的应用创建自动释放池也不是必须的，只是他们被忽略掉。

 

因此我们在编写线程主体入口的时候要先创建一个自动释放池。在线程结束的时候自动释放他。例如一个循环我们应该每次循环一次创建并释放该自动释放池。我们可以用这样的方法来防止我们应用程序内存占用太造成的性能问题。

 

设置异常处理：

之前提到过如果一个线程的异常未捕获，可能造成你的应用强制退出因为其他的线程也不能捕获，因此我们最好在线程的主体入口写一个捕获线程异常的函数try/catch，用来捕获任何位置的异常。

 

设置run loop

当一个编写一个线程时候，我们可以让他执行一个长期的操作很少中断，线程完成时候退出。也可以让我们的线程放入一个循环里面，让他动态处理操作。后面这种做法就类似在线程里面加入一个run loop。你的主线程默认启动一个run loop。但是你创建自己的线程需要自己添加启动。后面我们会详细介绍。

中断线程：

我们退出一个线程推荐方法是让他在主体入口正常的退出。虽然系统API提供了直接杀死线程的方法，但是这样做会阻止线程清理内存等工作。会造成潜在的问题之前也说了。

因此我们可以设置我们线程响应取消或者退出消息。对于长时间的操作，这意味着要周期性来检查这个消息是不是到来，这样线程有机会来清理完成最终退出。我们可以用run loop的输入源来检测这个消息的到来。具体后面会详细介绍。

 

 

分类: IOS多线程

标签: IOS多线程 线程属性的配置 多线程 run loop

 

• IOS代码规范(1)
• IOS多线程(3)
• IOS设计模式(6)
• IOS项目开发之网络编程(2)
• IOS学习资源(62)
• IOS转载(36)
• Objective-c官方文档翻译(7)
• OC(5)
• UI控件(4)
• 工具(3)
• 开源类库(1)
• 其他(8)
• 数据存储，数据持久化(2)
• 图形动画(2)
• 推送（push）(6)
• 网络（Xml,JSON,http请求方面）(8)
• 新特性处理(5)

«上一篇：IOS多线程之线程的创建

 

 

分类: 其它