Socket 一对多通信

　　这篇文章橙色的文字都是废话，不耐烦的园友可以跳过那些文字。包括这句话。

　　最初接触Socket编程的是在学校的java课上，可那时候没心学java，老师讲的Socket也没怎么理会，上机操作时，上网拷了一段C#的客户端和服务端代码，分别与java写的服务端和客户端进行通信。至于整个通信流程是怎样的没理会，直到写上一篇博文时才清楚。

　　还记得那时候上课老师问过如果一个服务端要跟两个客户端通信，那怎么办？接着他复制粘贴了一下创建Socket，绑定，监听那几行代码。

ServerSocket ss1 = new ServerSocket(8081);
Socket s1 = ss1.accept();
ServerSocket ss2 = new ServerSocket(8082);
Socket s2 = ss2.accept();

　　其实这样是多开了端口，的确是一个服务端对两个客户端通信了，但真正的一对多通信肯定不是这样吧，否则作为一台服务器，面对那么大的并发量，要开多少个端口才完事。如果我没理解错的话，java的accept也是同步的，这样就意味着一个客户端1跟这个服务端连接了之后，需要再来一个客户端2 (或者在那个客户端1) 与另一个端口连接了，才能正常通信。这样个人觉得不科学。

　　上网谷歌了一下，找到了一篇博文，是java的Socket的一对多通信，里面的一句话我一看眼发亮了：多执行一次Accept()。想C#与java类似的，于是尝试了一下，果然行。唉！看来学Socket编程的，都是参考java那部分的文章。

　　结合了对多线程的皮毛理解，想了一个办法实现一个服务端的与多个客户端交互，而且是用同一端口。大致是这样，在服务端的主线程执行一个循环去Accept客户端的Connet。每Accept一次，就开一个线程去负责与这个客户端通信。下面就上代码

首先是一些需要用到的变量

        static int socketCount;  //已经开的线程
        static object threadFlag; //多线程的锁旗标
        const int MAX_SOCKET_COUNT = 3;  //最大接受客户端数量

接着是Main方法里面的代码

            threadFlag = new object();
            socketCount = 0;

            Socket serverScoket = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
            IPEndPoint serverPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8081);

            serverScoket.Bind(serverPoint);
            serverScoket.Listen(10);

这里跟往常的Socket通信一样。建立终结点和Socket，绑定和监听。下面的就涉及到多线程了。

            Thread t = null;
            Socket clientSocket = null;
            try
            {
                while (true)
                {

                    //判断当前已开的线程数是否超出最大值，超出了则要等待
                    while (socketCount >= MAX_SOCKET_COUNT) Thread.Sleep(1000);
                    clientSocket = serverScoket.Accept();
                    //累计变量自增
                    socketCount++;
                    IPEndPoint clientPoint = clientSocket.RemoteEndPoint as IPEndPoint;
                    Console.WriteLine("client {0}:{1} connect",clientPoint.Address,clientPoint.Port);
                    t = new Thread(new ParameterizedThreadStart(ThreadConnect));
                    t.Start(clientSocket);
                }
            }
            finally
            {
                serverScoket.Close();
                serverScoket.Dispose();
                Environment.Exit(0);

            }

　　用了一个While循环去不断地有限制地接受客户端。每当接受了一个客户端，就开一个线程去处理它的通信。同时已开启线程数量累加一个。如果已开启的线程数大于最大值的话是停止接受的。防止开的线程过多压坏了服务端。

　　在接受时只是用了同步接受，没采用异步，因为感觉没必要，反正接受包在了一个死循环里面，还没接收到就让主线程一直卡在那句里面。等待接受了，才开始下一次接受等待。不过这里用的一个死循环觉得挺不妥的。没办法跳出循环，关闭Socket，释放资源等一系列操作不知道在哪里执行好。

最后上一段线程执行方法代码

        static void ThreadConnect(object clientObj)
        {
            Socket clientSocket = clientObj as Socket;
            IPEndPoint clientPoint = clientSocket.RemoteEndPoint as IPEndPoint;
            if (clientSocket == null)
            {
                lock (threadFlag)
                {
                    socketCount--;
                }
                return; 
            }
            clientSocket.Send(Encoding.ASCII.GetBytes("Hello world"),SocketFlags.None);
            byte[] datas;
            int rec;
            while (true)
            {
                datas = new byte[1024];
                rec = clientSocket.Receive(datas);
                //当客户端发来的消息长度为0时，表明结束通信
                if (rec == 0) break;

                string msg= "Msg has been receive length is "+rec;
                clientSocket.Send(Encoding.ASCII.GetBytes(msg),SocketFlags.None);
            }
            Console.WriteLine("client {0}:{1} disconnect", clientPoint.Address, clientPoint.Port);
            lock (threadFlag)
            {
                //减少当前已开的线程数
                socketCount--;
                clientSocket.Close();
                clientSocket.Dispose();
            }
        }

　　整个消息接收和发送过程都放在了死循环里面，由客户端发来的信息的长度来判定客户端是否终止通信，从而断定是否跳出循环。不过消息的收发可以用异步的，只不过这里没用上而已，感觉这里应该用。在最后的地方还要关闭Socket，释放资源。同时也要减少已开的线程数，毕竟这个线程已经完了。

　　在写完这篇文章时突然想到 “Sokect连接池 ”这个名词，接下来也尝试一下。用那个来做应该会更好。这个小程序的确简陋了，期待各位园友拍砖和吐槽。谢谢