Thrift TServer

1. poll的使用

#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <poll.h>

int main(void) {
    struct pollfd fds[1];
    int timeout_msecs = 10000;
    int ret;

    fds[0].fd = 0;
    fds[0].events = POLLIN;

    ret = poll(fds, 1, -1);// fds: 要检测的描述符 1: 描述符个数 -1: 无限等待
    if (ret < 0) {
        printf("poll error.\n");
        exit(1);
    }   

    if (fds[0].revents & POLLIN) {
        char ch; 
        read(fds[0].fd, &ch, 1); 
        printf("received pollin event: %c\n", ch);
    }   
    printf("exit...\n");
}

2.  简单的Server Client （使用poll）

SERVER

#include <iostream>                                                                                        
#include <sys/socket.h>                                                                                    
#include <arpa/inet.h>                                                                                     
#include <poll.h>                                                                                          
#include <memory.h>                                                                                        
#include <unistd.h>                                                                                        
using namespace std;                                                                                       
                                                                                                           
static int PORT = 8990;                                                                                    
static const char *IP = "127.0.0.1";                                                                       
static const int ACCEPT_BACKLOG = 5;                                                                       
                                                                                                           
class TServerSocket {                                                                                      
    public:                                                                                                
        void listen();                                                                                     
        int accept();                                                                                      
    private:                                                                                               
        int sock;                                                                                          
        struct sockaddr_in addr;                                                                           
};                                                                                                         
                                                                                                           
void TServerSocket::listen() {                                                                             
    sock = socket(PF_INET, SOCK_STREAM, 0);                                                                
    if (sock < 0)                                                                                          
      cout << "sock error" << endl;                                                                        
    addr.sin_family = PF_INET;                                                                             
    addr.sin_addr.s_addr = inet_addr(IP);                                                                  
    addr.sin_port = htons(PORT);                                                                           
    ::bind(sock, (struct sockaddr *)&addr,                                                                 
                sizeof(addr));                                                                             
                                                                                                           
    ::listen(sock, ACCEPT_BACKLOG);                                                                        
}                                                                                                          
                                                                                                           
int TServerSocket::accept() {                                                                              
    pollfd fds[1];                                                                                         
                                                                                                           
    while (true) {                                                                                         
        memset(fds, 0, sizeof(fds));                                                                       
        fds[0].fd = sock;                                                                                  
        fds[0].events = POLLIN;                                                                            
                                                                                                           
        int ret = poll(fds, 1, -1);                                                                        
        if (ret < 0) {                                                                                     
            std::cout << "poll error" << endl;                                                             
            continue;                                                                                      
        }                                                                                                  
        if (fds[0].revents & POLLIN) {                                                                     
            break;                                                                                         
        }                                                                                                  
    }                                                                                                      
    struct sockaddr_in cliAddr;                                                                            
    int size = sizeof(cliAddr);                                                                            
    int cliSock = ::accept(sock, (struct sockaddr *)&cliAddr, (socklen_t *)&size);                         
    return cliSock;                                                                                        
}                                                                                                          
                                                                                                           
int main() {                                                                                               
    TServerSocket server;                                                                                  
    server.listen();                                                                                       
    int client = server.accept();                                                                          
                                                                                                           
    char ch;                                                                                               
    read(client, &ch, 1);                                                                                  
                                                                                                           
    std::cout << "received " << ch << std::endl;                                                           
    return 0;                 
}

CLIENT

#include <sys/types.h>
#include <iostream>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <poll.h>
#include <memory.h>
#include <unistd.h>
using namespace std;

static int PORT = 8990;
static const char *IP = "127.0.0.1";
static const int ACCEPT_BACKLOG = 5;


class TSocket {
    public:
        int connect();
    private:
        int sock;
};

int TSocket::connect() {
    int err;

    sock = socket(PF_INET, SOCK_STREAM, 0); 
    if (sock < 0)
      cout << "sock error" << endl;
    struct sockaddr_in addr;
    addr.sin_family = PF_INET;
    addr.sin_addr.s_addr = inet_addr(IP);
    addr.sin_port = htons(PORT);

    int size = sizeof(addr);
    err = ::connect(sock, (struct sockaddr *)&addr, (socklen_t)size);

    if (err < 0)
      cout << "TSocket connect error" << endl;

    return sock;
}

int main() {
    TSocket client;
    int sock = client.connect();
    char ch = 'a';
    write(sock, &ch, 1); 
    return 0;
}

3. SERVER使用线程池

#include <iostream>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <poll.h>
#include <memory.h>
#include <unistd.h>
#include <thrift/concurrency/ThreadManager.h>
#include <thrift/concurrency/PosixThreadFactory.h>
#include <thrift/concurrency/Monitor.h>
#include <server/TSimpleServer.h>
#include <boost/shared_ptr.hpp>
using namespace apache::thrift::concurrency;
using namespace apache::thrift::server;
using namespace std;

static int PORT = 8990;
static const char *IP = "127.0.0.1";
static const int ACCEPT_BACKLOG = 5;

class TServerSocket {
    public:
        void listen();
        int accept();
    private:
        int sock;
        struct sockaddr_in addr;
};

void TServerSocket::listen() {
    sock = socket(PF_INET, SOCK_STREAM, 0); 
    if (sock < 0)
      cout << "sock error" << endl;
    addr.sin_family = PF_INET;
    addr.sin_addr.s_addr = inet_addr(IP);
    addr.sin_port = htons(PORT);
    ::bind(sock, (struct sockaddr *)&addr,
                sizeof(addr));

    ::listen(sock, ACCEPT_BACKLOG);
}

int TServerSocket::accept() {
    pollfd fds[1];

    while (true) {
        memset(fds, 0, sizeof(fds));
        fds[0].fd = sock;
        fds[0].events = POLLIN;

        int ret = poll(fds, 1, -1);
        if (ret < 0) {
            std::cout << "poll error" << endl;
            continue;
        }   
        if (fds[0].revents & POLLIN) {
            break;
        }   
    }   
    struct sockaddr_in cliAddr;
    int size = sizeof(cliAddr);
    int cliSock = ::accept(sock, (struct sockaddr *)&cliAddr, (socklen_t *)&size);
    return cliSock;
}
class MyTask : public Runnable {
    public:
        MyTask(boost::shared_ptr<TServerSocket> server) {
            server_ = server;
        }
        void run() {
            cout << "running now..." << std::endl;
            int client = server_->accept();
            char ch;
            read(client, &ch, 1);
            std::cout << "received " << ch << std::endl;

        }
    private:
        boost::shared_ptr<TServerSocket> server_;
};

int main() {
    boost::shared_ptr<TServerSocket> server(new TServerSocket);
    server->listen();

    int num_threads = 5;
    boost::shared_ptr<ThreadManager> threadManager =
        ThreadManager::newSimpleThreadManager(num_threads);
    boost::shared_ptr<PosixThreadFactory> threadFactory(new PosixThreadFactory());
    threadManager->threadFactory(threadFactory);
    threadManager->start();


    std::set<boost::shared_ptr<MyTask> > tasks;
    for (int i = 0; i < 20; i++) {
        tasks.insert(boost::shared_ptr<MyTask>(new MyTask(server)));
    }

    std::set<boost::shared_ptr<MyTask> >::iterator it;
    for (it = tasks.begin(); it != tasks.end(); it++) {
        threadManager->add(*it, 50, 50);
    }

    threadManager->join();
    return 0;
}

编译：

g++ TServerSocket.cpp -I/usr/local/include/thrift -lthrift -o server

注意需要thrift安装