1

我目前正在尝试实现一个在 linux 上运行的小型 FastCGI 多线程应用程序。我使用来自fastcgi.com的库。现在我不确定我是否真的理解网络服务器和我的应用程序之间的 FCGI 通信如何工作的概念。

首先，我在我的应用程序中创建一个新套接字。我返回文件描述符。

int socketIn = 0;
struct sockaddr_un local;
int length = 0;
int value = 1;

memset(&local, 0, sizeof(local));

local.sun_family = AF_UNIX;

strcpy(local.sun_path, socketPath);

length = strlen(local.sun_path) + sizeof(local.sun_family);

/* delete old unix socket */
if(-1 == unlink(socketPath))
{
    switch (errno)
    {
        case ENOENT:
        {
        }break;

        default:
        {
            printf("\n[Error]\tCould not remove old socket.");
            return -1;
        }
    }
}

/* create new socket */
if (-1 == (socketIn = socket(AF_UNIX, SOCK_STREAM, 0))) 
{
    printf("\n[Error]\tCould not create socket.");
    return -2;
}

/* bind socket */
if (-1 == bind(socketIn, (struct sockaddr *)&local, length)) 
{
    printf("\n[Error]\tCould not bind socket.");
    return -4;
}

return socketIn;

之后我初始化 FCGI 库：FCGX_Init();

现在我开始创建我的线程：

#define THREAD_COUNT 2

static int counts[THREAD_COUNT];

struct thread_data{
   int  thread_id;
   int  fcgiSocket;
};

struct thread_data thread_data_array[THREAD_COUNT];

int main(int argc, char** argv) 
{
   int i;
   pthread_t id[THREAD_COUNT];
   for (i = 1; i < THREAD_COUNT; i++)
   {
      thread_data_array[i].thread_id = i;
      thread_data_array[i].fcgiSocket = fcgi.fcgiSocket;
      pthread_create(&id[i], NULL, doit, &thread_data_array[i]);
   }

   thread_data_array[0].thread_id = 0;
   thread_data_array[0].fcgiSocket = fcgi.fcgiSocket;

   doit((void *)&thread_data_array[0]);

   return 0;
}

最后我的线程代码：

static void *doit(void *a)
{
    struct thread_data *my_data;
    my_data = (struct thread_data *) a;
    int rc, i;
    pid_t pid = getpid();
    FCGX_Request request;
    char *server_name;

    FCGX_InitRequest(&request, my_data->fcgiSocket, 0);

    for (;;)
    {
        static pthread_mutex_t accept_mutex = PTHREAD_MUTEX_INITIALIZER;
        static pthread_mutex_t counts_mutex = PTHREAD_MUTEX_INITIALIZER;

        /* Some platforms require accept() serialization, some don't.. */
        pthread_mutex_lock(&accept_mutex);
        rc = FCGX_Accept_r(&request);
        pthread_mutex_unlock(&accept_mutex);

        if (rc < 0)
            break;

        server_name = FCGX_GetParam("SERVER_NAME", request.envp);

        FCGX_FPrintF(request.out,
            "Content-type: text/html\r\n"
            "\r\n"
            "<title>FastCGI Hello! (multi-threaded C, fcgiapp library)</title>"
            "<h1>FastCGI Hello! (multi-threaded C, fcgiapp library)</h1>"
            "Thread %d, Process %ld<p>"
            "Request counts for %d threads running on host <i>%s</i><p><code>",
            my_data->thread_id, pid, THREAD_COUNT, server_name ? server_name : "?");

        pthread_mutex_lock(&counts_mutex);
        ++counts[my_data->thread_id];
        for (i = 0; i < THREAD_COUNT; i++)
            FCGX_FPrintF(request.out, "%5d " , counts[i]);
        pthread_mutex_unlock(&counts_mutex);

        FCGX_Finish_r(&request);
    }

    return NULL;
}

现在我担心我使用的套接字。3 个线程都将写入同一个套接字。使用多线程 FCGI 应用程序是否有其他或更好的方法来解决此问题？

4

2 回答 2

1

我正在回复一个旧帖子，但也许其他人可以从中受益。

“现在我担心我使用的套接字。3 个线程都会写入同一个套接字。”

没什么可担心的！

根据 Fast CGI 规范，每个请求都有关联的 ID，当线程将响应写回套接字时，它会将其服务的请求的 ID 关联起来。因此，即使线程以不同的顺序写入，Web 服务器也知道哪个响应是针对哪个请求的。规范在这里 -

http://www.fastcgi.com/drupal/node/6?q=node/22

只要消息的大小小于 PIPE_BUF，就可以保证对套接字的写入是原子的。libfcgi 将写入大小限制为 PIPE_BUF。您可以在以下文件中检查 -

http://www.fastcgi.com/mod_fastcgi/mod_fastcgi.h

#define FCGI_MAX_MSG_LEN  PIPE_BUF

希望这个解释能消除疑虑！

于 2013-11-11T18:05:14.067 回答
0

您可以创建一个处理所有套接字通信的新线程，并让其他线程将它们的消息放入从套接字线程读取的共享队列中。

于 2013-01-08T09:24:32.303 回答