c# socket线程池实现

服务器端：

    

PoolServer.cs类

    

using System;
using System.Collections.Generic;
using System.Text;

using System.Net;
using System.Net.Sockets;
using System.IO;
using System.Threading;

namespace Net.Common.Pool
{
    /// <summary>
    /// 服务器
    /// 1.调用构造方法：
    ///   (1)加载参数:端口、最大活动数量
    ///    (2)启用PooledConnectionHandler线程,根据最大活动数量创建线程,并且全部启动
    ///   PooledConnectionHandler线程,读取pool池,判断池内是否为空,如果不为空,则让线程安全的读取池内的第一个,并且进行业务处理
    ///   2.开启服务
    ///    (1)将TcpListener对象初始化
    ///       (2)等待客户机的请求,调用AcceptConnections()方法
    ///
    ///         @author layicr
    /// </summary>
    public class PoolServer
    {
        /// <summary>
        /// 最大活动数量
        /// </summary>
        private int maxConnections;
        /// <summary>
        /// 最大活动数量
        /// </summary>
        public int MaxConnections
        {
            get { return maxConnections; }
            set { maxConnections = value; }
        }
        /// <summary>
        /// 端口
        /// </summary>
        private int port;
        /// <summary>
        /// 端口
        /// </summary>
        public int Port
        {
            get { return port; }
            set { port = value; }
        }
        /// <summary>
        /// 第几张网卡，默认为第一个，值为0
        /// </summary>
        private int addressIndex = 0;
        /// <summary>
        /// 第几张网卡，默认为第一个，值为0
        /// </summary>
        public int AddressIndex
        {
            get { return addressIndex; }
            set { addressIndex = value; }
        }

        /// <summary>
        /// 是否打开服务
        /// </summary>
        private bool reLease = false;

        /// <summary>
        /// 线程集合
        /// </summary>
        private List<Thread> listConnectionThread = new List<Thread>();

        private TcpListener listener = null;
        private TcpClient client = null;

        /// <summary>
        ///
        /// </summary>
        public PoolServer()
        {
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="port">端口</param>
        /// <param name="maxConnections">最大活动数量</param>
        public PoolServer(int port, int maxConnections)
        {
            this.port = port;
            this.maxConnections = maxConnections;
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="addressIndex">第几张网卡</param>
        /// <param name="port">端口</param>
        /// <param name="maxConnections">最大活动数量</param>
        public PoolServer(int addressIndex, int port, int maxConnections)
        {
            this.addressIndex = addressIndex;
            this.port = port;
            this.maxConnections = maxConnections;
        }

/// <summary>
        /// 启动服务
/// </summary>
        public void ServerStart()
        {
            this.reLease = true;
            IPHostEntry IpEntry = Dns.GetHostEntry(Dns.GetHostName()); //得到主机IP
            IPAddress iPAddress = IpEntry.AddressList[addressIndex];
            listener = new TcpListener(iPAddress, this.port);
            listener.Start();
            //开启线程
            SetUpHandlers();
            // 允许客户机连接到服务器,等待客户机请求
            AcceptConnections();
        }

        /// <summary>
        ///  停止服务
        /// </summary>
        public void ServerStop()
        {
            if (listener != null)
            {
                try
                {
                    listener.Stop();
                    listener = null;
                    //清空池数据
                    PoolConnectionHandler.pool.Clear();
                    reLease = false;
                    //让PooledConnectionHandler线程停止
                    foreach(Thread item in listConnectionThread)
                    {
                        //停止
                        item.Abort();
                    }
                    //清空
                    listConnectionThread.Clear();
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message);
                }
            }
        }

        /// <summary>
        /// 允许客户机连接到服务器,等待客户机请求
        /// 1.开启一个线程
        /// </summary>
        private void AcceptConnections()
        {
            new Thread(ListenerStart).Start();
        }

        /// <summary>
        /// 允许客户机连接到服务器,等待客户机请求
        /// 2.判断当前reLease(是否启用服务)的值是否为true
        /// 如果没有启用服务,则线程关闭
        /// 如果启用服务,则开始等待客户机请求,如果受到了客户机的请求,则加入池中
        /// </summary>
        private void ListenerStart()
        {
            while (reLease)
            {
                try
                {
                    client = listener.AcceptTcpClient();
                    HandleConnection(client);
                }
                catch (Exception e)
                {
                    //
                    Console.WriteLine(e.Message);
                }
            }
        }

        /// <summary>
        /// 将请求加入池中
        /// </summary>
        /// <param name="client"></param>
        private void HandleConnection(TcpClient client)
        {
            PoolConnectionHandler.ProcessRequest(client);
        }

        /// <summary>
        ///  开启PooledConnectionHandler线程
        /// </summary>
        private void SetUpHandlers()
        {
            Thread thread = null;
            for (int i = 0; i < maxConnections; i++)
            {
                PoolConnectionHandler currentHandler = new PoolConnectionHandler();
                thread = new Thread(new ThreadStart(currentHandler.Run));
                thread.Name = "Thread(" + i+")";
                thread.Start();
                listConnectionThread.Add(thread);
            }
        }

    }
}

    

    

PoolConnectionHandler.cs类

    

using System;
using System.Collections.Generic;
using System.Text;

using System.Net;
using System.Net.Sockets;
using System.IO;
using System.Threading;

namespace Net.Common.Pool
{
    public class PoolConnectionHandler
    {
        /// <summary>
        ///  池
        /// </summary>
        public static LinkedList<TcpClient> pool = new LinkedList<TcpClient>();

        /// <summary>
        ///
        /// </summary>
        protected TcpClient client = null;

        /// <summary>
        ///
        /// </summary>
        public PoolConnectionHandler() { }

        /// <summary>
        /// 业务处理
        /// </summary>
        public void HandleConnection()
        {

            try
            {
                //这里调用，   业务层的方法

                HandleMain.Handle(client);

            }
            catch
            { }

        }

        /// <summary>
        /// 将未处理的请求加入池中
        /// </summary>
        /// <param name="requestToHandle"></param>
        public static void ProcessRequest(TcpClient requestToHandle)
        {
            //对池进行加锁
            lock (pool)
            {
                //把未处理的请求加入池
                pool.AddLast(requestToHandle);
                //将等待线程被唤醒
                Monitor.PulseAll(pool);
            }
        }

 

        /// <summary>
        ///  一直接读取pool(池),并且对pool进行加锁,判断其集合是否为空
        /// 如果pool为空,则一直的读取
        /// 如要pool不为空,则取出第一个值,到了这一步锁解除(保存池取值的过程是安全,取出的值是唯一),接着执行handleConnection
        /// </summary>
        public void Run()
        {
            while (true)
            {
                try
                {
                    lock (pool)
                    {
                        while (pool.Count == 0)
                        {
                            Monitor.Wait(pool);
                        }
                        //取第一个值
                        client = pool.First.Value;
                        //移除
                        pool.RemoveFirst();
                    }
                    HandleConnection();
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message);
                }
            }
        }
    }
}

 

 

HandleMain.cs业务类：

using System;
using System.Collections.Generic;
using System.Text;

using System.Net;
using System.Net.Sockets;
using System.IO;

namespace Net.Common.Pool
{
    /// <summary>
    /// 业务类，测试类
    /// </summary>
   public  class HandleMain
    {
       public static void Handle(TcpClient client)
       {
           Console.WriteLine("当前线程：" + System.Threading.Thread.CurrentThread.Name);

           NetworkStream networkStream = null;
           //输入
           StreamReader streamReader = null;

           FileStream fileStream = null;
           byte[] buffer = null;

           int length = 3*1024;

           try
           {
               networkStream = client.GetStream();
               streamReader = new StreamReader(networkStream);

               //文件名
               string fileName = streamReader.ReadLine();

               fileStream = new FileStream(@"E:\1\" + fileName, FileMode.Create, FileAccess.Write);

               int readLength = 0;

            // int   sumLength = 0;
          //     DateTime myDtStart = DateTime.Now;

               buffer = new byte[length];

               while ((readLength = networkStream.Read(buffer, 0, length)) > 0)
               {
                   fileStream.Write(buffer, 0, readLength);
                   fileStream.Flush();

                   //总量
                   //   sumLength += readLength;
                   //double total = sumLength / 1000;

                   //    TimeSpan ts = DateTime.Now - myDtStart;
                   //当前速度
                   //     double speed = total / ts.TotalSeconds;
               }
               fileStream.Flush();
           }
           catch (Exception ex)
           {
               Console.WriteLine(ex.Message);
           }
           finally
           {
               if (fileStream != null)
               {
                   fileStream.Close();
               }
               if (streamReader != null)
               {
                   streamReader.Close();
               }
               if (networkStream != null)
               {
                   networkStream.Close();
               }
               if (client != null)
               {
                   client.Close();
               }
           }
       }
 
    }
}

                   

 

 

运行服务器端：

    int port = 3848;
    PoolServer poolServer = new PoolServer(port, 10);
    poolServer.ServerStart();                  

 

 

客户端测试：

using System.Net;
using System.IO;
using System.Net.Sockets;

 

 

public void Send(){

            string serverIP = "192.168.1.138";//服务器IP地址
            int port = 3848;//端口号
            string filePath = "c:\\1.jpg";//要传输的文件

           

 int length = 2048;

            TcpClient client = null;
            NetworkStream networkStream = null;
            FileStream fileStream = null;
            StreamWriter streamWriter = null;

            byte[] buffer = null;
            int readLength = 0;

            String msg = null;//传输消息
            string fileExt = null; //文件的后缀

            while (true)
            {
                System.Threading.Thread.Sleep(900);//很重要/
                try
                {
                    //连接服务器
                    client = new TcpClient(serverIP, port);

                    client.SendTimeout = 60 * 1000;//发送超时值,以毫秒为单位

                    networkStream = client.GetStream();

                    //输出
                    streamWriter = new StreamWriter(networkStream);

                    //输入
                    //  StreamReader sr = new StreamReader(networkStream);

                    fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.None);

                    //得到后缀，包括"."
                    fileExt = Path.GetExtension(filePath).ToLower();

                    //远程服务器生成的文件名称
                    msg = System.Guid.NewGuid().ToString() + fileExt;

                    //传输消息
                    streamWriter.WriteLine(msg);
                    streamWriter.Flush();

                    buffer = new byte[length];

                    while ((readLength = fileStream.Read(buffer, 0, length)) > 0)
                    {
                        networkStream.Write(buffer, 0, readLength);
                        networkStream.Flush();
                    }
                    networkStream.Flush();
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message);
                }
                finally
                {
                    if (fileStream != null)
                    {
                        fileStream.Close();
                    }
                    if (streamWriter != null)
                    {
                        streamWriter.Close();
                    }
                    if (networkStream != null)
                    {
                        networkStream.Close();
                    }
                    if (client != null)
                    {
                        client.Close();
                    }
                }
            }

}