线程池

池

一组资源的集合。为了提高服务器性能，以空间换时间，即“浪费”服务器的硬件资源，以换取其运行效率。

静态资源分配方式：资源在服务器启动之初就被完全创建好并初始化。
对于预期应该分配多少资源，有两种方案：

• 分配“足够多”的资源，即针对每个可能的客户连接都分配必要的资源，但会导致资源的浪费；

• 预先分配一定的资源，此后发现资源不够用，就再动态分配一些加入池中。

  池可以看作是服务器管理系统资源的应用层设施，避免了服务器对内核的频繁访问。因为服务器在处理客户请求时，如果它需要相关的资源，可以直接从池中获取，无需动态分配，而且直接从池中获取资源比动态分配资源速度快，动态分配需要系统调用。

---

根据不同的资源类型，池分为多种，

• 内存池
• 进程池
• 线程池
• 连接池

内存池：用于socket的接收缓存和发送缓存。对于某些长度有限的客户请求，比如HTTP请求，预先分配一个大小足够的接收缓存区是合理的。当客户请求的长度超过接收缓冲区的大小时，可以选择丢弃请求或动态扩大接收缓冲区。

进程池和线程池都是用于并发编程。当需要一个工作进程或工作线程来处理新到的客户请求时，可以直接从进程池或线程池中取得一个执行实体，而无需动态调用fork或pthread_create等函数来创建进程或线程。

连接池：是服务器预先和数据库程序建立的一组连接的集合。用于服务器或服务器机群的内部永久连接。当某个逻辑单元需要访问数据库时，它可以直接从连接池中取得一个连接的实体并使用。待访问完数据库，逻辑单元再将该连接返还给连接池。

---

以线程池实现为例： 线程池的实现有多种方式，主要区别点在于主线程完成那些工作：

1、主线程负责对监听socket和所有的连接socket进行I/O复用，工作线程负责和有通讯需求的客户端通讯。如下图所示：

2、主线程仅仅负责监听socket，连接socket的接受以及与客户端通讯都有工作线程完成。如下图所示：

由于同一个进程的所有线程之间共享所有打开的文件描述符、全局区数据。所以，线程之间传递数据简单的多。在此，我们实现第一种情况下的线程池。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <epoll.h>

#define MAX 128
int epfd = -1;

sem_t sem;
int fds[MAX];
int count = 0;

void initfds()
{
    int i = 0;
    for(;, i < MAX; ++i)
    {
        fds[i] = -1;
    }
}

int getfds()
{
    if(fds[0] != -1)
    {
        int c = fds[0];
        int i = 0;
        for(; i < count && i < MAX - 1; ++i)
        {
            fds[i] = fds[i + 1];
        }
        fds[MAX - 1] = -1;

        return c;
    }
}

//将文件描述符设置成非阻塞的
int setnonblocking(int fd)
{
    int old = fcntl(fd, F_GETFL);
    int new = old | O_NONBLOCK;
    fcntl(fd, F_SETFL, new);
    return old;
}

void * thread_fun(void *arg)
{
    sem_wait(&sem);
    int fd = getfds();
    while(1)
    {
        char buff[1024] = {0};
        int n = recv(fd, buff, 1023, 0);
        if(n < 0)
        {
            if((error == EAGAIN) || (error == EWOULDBLOCK))
            {
                send(fd, "OK", 2, 0);
                break;
            }
            epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
            close(fd);
            break;
        }
        if(n == 0)
        {
            epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
            close(fd);
            break;
        }

        printf("%d: %s\n", fd, buff);    
    }
}

int main()
{
    sem_init(&sem, 0, 0);
    initfds();

    int i = 0;
    for(; i < 3; ++i)
    {
        pthread_t id;
        int ret = pthread_create(&id, NULL, thread_fun, NULL);
        assert(ret == 0);
    }

    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    assert(listenfd != -1);

    struct sockaddr_in  ser, cli;
    memset(&ser, 0, sizeof(ser));
    ser.sin_family = AF_INET;
    ser.sin_port = htons(6000);
    ser.sin_addr.s_addr = inet_addr("127.0.0.1");

    int ret = bind(listenfd,  (struct sockaddr*)&ser, sizeof(ser));
    assert(ret != -1);

    listen(listenfd, 5);

    epfd = epoll_create(5);
    assert(epfd != -1);

    struct epoll_event  event;
    event.events = EPOLLIN;
    event.data.fd = listenfd;

    epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &event);

    struct epoll_event events[MAX];

    while(1)
    {
        int n = epoll_wait(epfd, events, MAX, -1);
        if(n < 0)
        {
            exit(0);
        }
        else if(n == 0)
        {
            printf("timeout\n");
            continue;
        }
        else
        {
            int i = 0;
            for(; i < n; ++i)
            {
                int fd = events[i].data.fd;
                if(fd == listenfd)
                {
                    int len = sizeof(cli);
                    int c = accept(fd, (struct sockaddr*)&cli, &len);
                    assert(c != -1);
                    event.events = EPOLLIN | EPOLLET;
                    event.data.fd = c;
                    epoll_ctl(epfd, EPOLL_CTL_ADD, c, &event);
                    setnonblockint(c);
                }
                else
                {
                    if(count < MAX)
                    {
                        fds[count++] = fd;
                     }
                    else
                    {
                        printf("queue full\n");
                        continue;
                    }
                    sem_post(&sem);
                }
            }
        }
    }
}