1

我正在尝试使用线程池对 Web 服务器进行编程，主线程在其中建立连接，将其传递给线程，然后线程对其进行处理。

我为每个线程都有一个结构，还有一个 workQueue 来保存它们

struct worker {
    pthread_t* thread;
    struct queue* workerQueue;
    char* busy;
    int connfd;
    int id;
};

struct queue {
    int start;
    int end;
    int size;
    struct worker* workers;
};

主线程设置队列和线程，并循环连接

  struct queue* workerQueue;
            workerQueue = (struct queue*) constructQueue(10);
            int j;
            int* testParam;
            //create workers and put in queue
            for(j=0;j<5;j++)
            {
                struct worker* w = &(workerQueue->workers[j]);
                w = (struct worker*)constructWorker(processConnection,testParam, workerQueue,j);
                queueAdd(workerQueue,w);
            }
connection = accept(fd, (struct sockaddr *) &cliaddr, &cliaddrlen);
        puts("got connection\n");


         w =(struct worker*) queueRemove(workerQueue);
        //w->connfd = connection;
        w->busy = "BUSY";
        printf("Worker %d has accepted a connection and is %s\n",w->id,w->busy);

使用这两个功能..

   struct queue* constructQueue(int numThreads)
    {
        struct queue* q = (struct queue *)malloc(sizeof(struct queue));
        q->start = 0;
        q->end = 0;
        q->workers = (struct worker* )malloc(sizeof(struct worker)*numThreads);
        q->size = numThreads;
        return q;
    }

struct worker* constructWorker(void* (*function)(void*),void* param, struct queue* wq, int i)
{
    struct worker* w = (struct worker*)malloc(sizeof(struct worker));
    w->workerQueue = wq;
    char * busy = (char*)malloc(10);
    w->busy= "IDLE";
    w->connfd = 0;
    w->id = i;
    pthread_t t;
    w->thread = &t; 
    pthread_create(w->thread,NULL,function,w);
    return w;
}

...线程使用的功能是

void* processConnection(void* serverThread)
{
        //cast serverthread
        struct worker* w;
        char* b;
        int threadID;
        w = (struct worker*)serverThread;
        b = w->busy;
        threadID = w->id;


        while (1)
        {
            char c[10];
            printf("\nbusy: %s, thread: %d\n",b,threadID);
            gets(c)

;

我想要发生的是：创建工人，忙设置为空闲，并开始忙于等待。然后在主循环中，一个连接被接受并分配给一个worker，worker的busy值被设置为BUSY。然后在 processConnections 中，如果一个线程很忙，它应该实际处理它。问题是，虽然我的队列包含指针而不是值，但当我在主线程中更新工作人员时，它似乎不会影响 processConnection 中工作人员的值。我可以将busy设置为BUSY并让它在主循环中打印出来，但是busy的值在processConnection中总是IDLE。有任何想法吗？

4

3 回答 3

1

尝试更改busyto的定义

volatile char * busy;

这告诉编译器这个变量的值可以在代码运行时改变，即使代码没有显式访问那个变量。

但是，您还有许多其他问题。例如，

char * busy = (char*)malloc(10);
w->busy= "IDLE";

将泄漏已分配的内存malloc。不要尝试使用字符串来跟踪状态。enum {IDLE, BUSY}而是定义一个并定义busy为该类型的变量。

于 2013-02-26T05:33:19.290 回答
1

您可能没有在另一个线程中看到更新的值，因为线程之间没有同步点。编译器优化和缓存（内）一致性是发生这种情况的两个原因。要保持相同的策略，您需要一个内存屏障。如果使用 gcc，最简单的方法是__sync_synchronize()在读取共享数据之前和写入共享数据之后放置。

您需要解决的另一件事是当您这样做时

pthread_t t;
w->thread = &t;

在该函数返回后，内存t很容易被重用。您不能获取局部变量的地址并将其存储在超出函数生命周期的方式中。正确的做法是在其中输入一个pthread_t字段struct worker并将该字段的地址传递给pthread_create：

pthread_create(&w->thread, ...);
于 2013-02-26T04:46:29.723 回答
0

我建议添加 2 个互斥锁，一个在工作线程，一个在队列

   struct worker {
      pthread_t* thread;
      struct queue* workerQueue;
      mutex_t QueueMutex;
      char* busy;
      int connfd;
      int id;
      };`

   struct queue {
       int start;
       int end;
       int size;
       mutex_t workermutex;
       struct worker* workers;
   };

您的代码应如下所示

创建新套接字时，锁定workermutex，然后分配一个连接

工作线程每次都会锁定 QueueMutex 并从队列中添加/删除数据以进行处理。

于 2013-02-26T20:21:56.573 回答