c++ socket 服务器 线程池 海量 并发 windoes linux 源代码 SPServer

http://blog.sina.com.cn/s/blog_6294abe701011tyl.html

对socket服务器海量并发比较感兴趣，从网上搜了一些材料，和大家分享一下：

一、SPServer： 一个基于线程池（包括HAHS和LF）的开源服务器框架

SPServer 是一个实现了半同步/半异步(Half-Sync/Half-Async)和领导者/追随者(Leader/Follower) 模式的服务器框架，能够简化 TCP server 的开发工作。

SPServer 使用 c++ 实现，目前实现了以下功能：
1.封装了 TCP server 中接受连接的功能；
2.使用非阻塞型I/O和事件驱动模型，基于 libevent；
3.对于 HSHA 线程池，由主线程负责处理所有 TCP 连接上的数据读取和发送，因此连接数不受线程数的限制；主线程读取到的数据放入队列，由一个线程池处理实际的业务；
4.对于 LF 线程池，由线程池中的线程轮流获得 leader 角色进行处理；
5.一个 http 服务器框架，即嵌入式 web 服务器。
6.从 0.7 版本开始支持 ssl 。

项目主页
[url=http://code.google.com/p/spserver/]http://code.google.com/p/spserver/

下载地址
[url=http://freshmeat.net/redir/spserver/68862/url_tgz/spserver-0.3.src.tar.gz]http://spserver.googlecode.com/files/spserver-0.6.src.tar.gz 
[url=http://code.google.com/p/spserver/downloads/list]http://code.google.com/p/spserver/downloads/list

详细的介绍
[url=http://iunknown.javaeye.com/blog/59804]http://iunknown.javaeye.com/blog/59804

HSHA 模式
[url=http://www.cs.wustl.edu/~schmidt/PDF/HS-HA.pdf]http://www.cs.wustl.edu/~schmidt/PDF/HS-HA.pdf

LF 模式
[url=http://www.cs.wustl.edu/~schmidt/PDF/lf.pdf]http://www.cs.wustl.edu/~schmidt/PDF/lf.pdf

关于 HSHA 和 LF 的一些介绍
[url=http://iunknown.javaeye.com/blog/60414]http://iunknown.javaeye.com/blog/60414

项目中包含一个线程池子项目
http://iunknown.javaeye.com/blog/38544 

以上是从 http://www.chinaunix.net/jh/23/957813.html 中粘贴过来的，有兴趣可以看看这个链接。

 

二、http://www.pudn.com/downloads124/sourcecode/unix_linux/network/detail527666.html

这里有一个线程池+socket的服务器源代码，有兴趣的可以学习一下。

三、linux下最好的io模型是epoll，有点类似于windows下的完成端口，感觉select支持1000个左右就差不多了。要想支持10k以上的连接，需要考虑的问题有很多。
你可以看一下下面这个链接（C10k Problem）。
http://www.kegel.com/c10k.html

四、在网上无意看到一个多线程的Socket服务器端例子，觉得非常不错。特别是其中的线程池的思想，简单而且高效。虽然JDK1.5开始已经自带了线程池包，但该代码不失为学习Socket和多线程的一个好的入门例子。

下面的代码是对该例子的简单整理，补充了注释。

【代码一】PooledConnectionHandler：后台处理类

package server;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.LinkedList;
import java.util.List;


public class PooledConnectionHandler implements Runnable {

    
    protected Socket connection;

    
    protected static List pool = new LinkedList();

    
    public PooledConnectionHandler() {
    }
    
    
    public void run() {
        while (true) {
            // 因为可能有多个线程同时去Pool中取Socket进行处理。
            // 所以这里我们需同步，防止同一个请求被多次处理
            synchronized (pool) {
                while (pool.isEmpty()) {
                    try {
                        pool.wait();// 没有请求到来则等待
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 从池中取出一个Socket，准备进行处理
                connection = (Socket) pool.remove(0);
            }
            // 取到Socket后则不需要同步了，因为此时是Connection是对象
            // 级属性，在线程内部自己处理，不涉及公共资源的访问
            handleConnection();
        }
    }
    
    
    public static void processRequest(Socket requestToHandle) {
        // 因为有可能在向池中塞请求的时候，另外一个线程
        // 正在从池中取Socket，所以这里需要同步一下
        synchronized (pool) {
            // 将来自客户端的请求添加到请求队列末尾
            pool.add(pool.size(), requestToHandle);
            // 通知其它正在等待的线程有新请求来到，
            // 此时所有处于wait状态的线程将被唤醒
            pool.notifyAll();
        }
    }    

    
    public void handleConnection() {
        try {
            PrintWriter streamWriter = new PrintWriter(connection
                    .getOutputStream());
            BufferedReader streamReader = new BufferedReader(
                    new InputStreamReader(connection.getInputStream()));

            String fileToRead = streamReader.readLine();
            BufferedReader fileReader = new BufferedReader(new FileReader(
                    fileToRead));

            String line = null;
            while ((line = fileReader.readLine()) != null)
                streamWriter.println(line);

            fileReader.close();
            streamWriter.close();
            streamReader.close();
        } catch (FileNotFoundException e) {
            System.out.println("");
        } catch (IOException e) {
            System.out.println("" + e);
        }
    }    
}

【代码二】PooledRemoteFileServer：多线程服务器端，负责创建线程池并等待客户端的连接请求

package server;

import java.io.IOException;
import java.net.BindException;
import java.net.ServerSocket;
import java.net.Socket;


public class PooledRemoteFileServer {

    
    protected int maxConnections;

    
    protected int listenPort;

    
    protected ServerSocket serverSocket;

    
    public PooledRemoteFileServer(int aListenPort, int maxConnections) {
        listenPort = aListenPort;// 监听端口
        this.maxConnections = maxConnections;// 最大同时连接
    }

    
    public void setUpHandlers() {
        for (int i = 0; i < maxConnections; i++) {
            PooledConnectionHandler currentHandler = new PooledConnectionHandler();
            // 线程启动后将一直监控Socket队列，以轮询的方式
            // 监控是否有新的客户端请求到来，如果有的话则取
            // 出处理，无的话则继续等待直至请求到来
            new Thread(currentHandler, "Handler" + i).start();
        }
    }

    
    public void acceptConnections() {
        try {
            ServerSocket server = new ServerSocket(listenPort, 5);
            Socket incomingConnection = null;
            while (true) {
                incomingConnection = server.accept();
                handleConnection(incomingConnection);
            }
        } catch (BindException be) {
            System.out.println("");
        } catch (IOException ioe) {
            System.out.println("" + listenPort);
        }
    }

    
    protected void handleConnection(Socket connectionToHandle) {
        PooledConnectionHandler.processRequest(connectionToHandle);
    }

    public static void main(String args[]) {
        PooledRemoteFileServer server = new PooledRemoteFileServer(1001, 3);
        // 初始化线程池
        server.setUpHandlers();
        // 开始在指定端口等待到来的请求
        server.acceptConnections();
    }
}

这个例子的精髓是在PooledConnectionHandler类，它首先创建一个公共的全局“线程池”(LinkList)，然后启动线程监控线程池，与此同时服务器端在接收到客户端请求后将请求加到“线程池”中，这两个动作是异步的，在加的时候不允许读，在读得到时候不允许加(通过synchronized关键字控制)，而且多个线程之间并不会互相影响，因为其中的connection属性是对象级的。

从这个例子中我们也可以学到在多线程的情况下，哪些变量是必须设置为全局的(static)，哪些是必须设置为对象级的：即会被多个线程访问的资源必须设置为全局的，而跟线程处理状态，结果有关的属性一般必须设置为对象级的，以防止互相干扰。

其次就是在多线程情况下，哪些方法是可以设置为static的而不会出现线程安全的问题，哪些方法是不能设置为静态方法的：如果方法是属于控制流程，通知，派发的，那么一般可以设置为静态的。因为这些方法一般不需要多个，一个就够了。就如同控制器只要一个就够了。而业务逻辑实现方法一般不能设置为静态的，因为静态方法不能引用对象变量(非静态变量)，但业务逻辑通常是需要针对不同的用户做出不同的处理的，所以几乎可以肯定的说是绝对会出现对象变量的。
五、

linux下多线程socket监听的c程序(例子)  

 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define PORT 8888

void *yourfunction(void *connect_fd)
{
int connfd = *((int *)connect_fd);
        。。。。
} //在这里面直接对connfd调用read和write函数就可以和客户端收发数据了。


int main(void)
{
int sockfd, n, connfd;
pthread_t tid;
struct sockaddr_in servaddr;

sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd == -1)
{
  perror("socket:");
  exit(1);
}

bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(PORT);

n = bind(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
if (n == -1)
{
  perror("bind:");
  exit(1);
}

n = listen(sockfd, 20);
if (n == -1)
{
  perror("listen:");
  exit(1);
}

while (1)
{
  connfd = accept(sockfd, (struct sockaddr *)&servaddr, NULL);
  pthread_create(&tid, NULL, yourfunction, (void *)&connfd);
}

return 0;
}

暂时就这些吧，希望对学习这一块的朋友有所帮助。