全局静态变量的副作用

Question

我正在编写一个UDP服务器，该服务器当前从UDP接收数据，将其包装在一个对象中并将它们放入并发队列。 并发队列是此处提供的实现： http : //www.justsoftwaresolutions.co.uk/threading/implementing-a-thread-safe-queue-using-condition-variables.html

工作线程池将数据从队列中拉出进行处理。

队列在全局上定义为：

static concurrent_queue<boost::shared_ptr<Msg> > g_work_queue_;

现在，我遇到的问题是，如果我只是编写一个函数来生成数据并将其插入队列并创建一些使用者线程以将其拉出，那么它就可以正常工作。 但是，当我添加基于UDP的生产者时，工作线程就不再收到队列中数据到达的通知。

我已经将问题跟踪到并发队列中push函数的末尾。 特别是以下行：the_condition_variable.notify_one（）; 使用我的网络代码时不返回。

因此，问题与我编写网络代码的方式有关。

这是它的样子。

enum
{
    MAX_LENGTH = 1500
};


class Msg
{
  public:
    Msg()
    {
       static int i = 0;
       i_ = i++;
       printf("Construct ObbsMsg: %d\n", i_);
    }

    ~Msg()
    {
       printf("Destruct ObbsMsg: %d\n", i_);
    }

    const char* toString() { return data_; }

  private:
    friend class server;

    udp::endpoint sender_endpoint_;
    char data_[MAX_LENGTH];
    int i_;
};

class server
{
public:
  server::server(boost::asio::io_service& io_service)
    : io_service_(io_service),
      socket_(io_service, udp::endpoint(udp::v4(), PORT))
  {
    waitForNextMessage();
  }  

  void server::waitForNextMessage()
  {
    printf("Waiting for next msg\n");

    next_msg_.reset(new Msg());

    socket_.async_receive_from(
        boost::asio::buffer(next_msg_->data_, MAX_LENGTH), sender_endpoint_,
        boost::bind(&server::handleReceiveFrom, this,
                    boost::asio::placeholders::error,
                    boost::asio::placeholders::bytes_transferred));
  }

  void server::handleReceiveFrom(const boost::system::error_code& error, size_t bytes_recvd)
  {
    if (!error && bytes_recvd > 0) {
        printf("got data: %s. Adding to work queue\n", next_msg_->toString());
        g_work_queue.push(next_msg_); // Add received msg to work queue
        waitForNextMessage();
    } else {
        waitForNextMessage();
    } 
  }

private:
  boost::asio::io_service& io_service_;
  udp::socket socket_;

  udp::endpoint sender_endpoint_;
  boost::shared_ptr<Msg> next_msg_;
}

int main(int argc, char* argv[])
{
    try{
      boost::asio::io_service io_service;
      server s(io_service);
      io_service.run();
    catch(std::exception& e){
      std::err << "Exception: " << e.what() << std::endl;
    }
    return 0;
}

现在，我发现如果handle_receive_from能够返回，则并发队列中的notify_one（）会返回。 所以我认为这是因为我有一个递归循环。 那么开始侦听新数据的正确方法是什么？ 异步udp服务器示例存在缺陷，因为我基于它们已经在做什么。

编辑：好的问题甚至变得更奇怪。

我在这里没有提到的是我有一个称为处理器的类。 处理器看起来像这样：

class processor
{
public:
   processor::processor(int thread_pool_size) :
      thread_pool_size_(thread_pool_size) { }

  void start()
  {
    boost::thread_group threads;
    for (std::size_t i = 0; i < thread_pool_size_; ++i){
        threads.create_thread(boost::bind(&ObbsServer::worker, this));
    }
  }

  void worker()
  {
    while (true){
        boost::shared_ptr<ObbsMsg> msg;
        g_work_queue.wait_and_pop(msg);
        printf("Got msg: %s\n", msg->toString());
    }
  }

private:
  int thread_pool_size_;
};

现在看来，如果我自己提取worker函数并从main启动线程。 有用！ 有人可以解释为什么线程在类之外能按我期望的那样起作用，但在内部却有副作用吗？

EDIT2：现在变得更加奇怪了

我提取了两个功能（完全相同）。

一个叫做消费者，另一个叫做工人。

即

void worker()
{
    while (true){
        boost::shared_ptr<ObbsMsg> msg;
        printf("waiting for msg\n");
        g_work_queue.wait_and_pop(msg);
        printf("Got msg: %s\n", msg->toString());
    }
}

void consumer()
{
    while (true){
        boost::shared_ptr<ObbsMsg> msg;
        printf("waiting for msg\n");
        g_work_queue.wait_and_pop(msg);
        printf("Got msg: %s\n", msg->toString());
    }
}

现在，使用者位于server.cpp文件的顶部。 即我们的服务器代码所在的位置。

另一方面，worker驻留在processor.cpp文件中。

现在，我现在根本不使用处理器。 现在，主要功能如下：

void consumer();
void worker();

int main(int argc, char* argv[])
{
    try {
        boost::asio::io_service io_service;
        server net(io_service);
        //processor s(7);

        boost::thread_group threads;
        for (std::size_t i = 0; i < 7; ++i){
            threads.create_thread(worker); // this doesn't work
            // threads.create_thread(consumer); // THIS WORKS!?!?!?
        }

//        s.start();

        printf("Server Started...\n");
        boost::asio::io_service::work work(io_service);
        io_service.run();

        printf("exiting...\n");
    } catch (std::exception& e) {
        std::cerr << "Exception: " << e.what() << "\n";
    }

    return 0;
}

消费者为什么能够接收排队的物品，而工人却不能。 它们是具有不同名称的相同实现。

这没有任何意义。 有任何想法吗？

这是收到txt“ Hello World”时的示例输出：

输出1：不工作。 调用辅助函数或使用处理器类时。

Construct ObbsMsg: 0
waiting for msg
waiting for msg
waiting for msg
waiting for msg
waiting for msg
waiting for msg
Server Started...
waiting for msg
got data: hello world. Adding to work queue
Construct ObbsMsg: 1

输出2：在调用与工作器函数相同的使用者函数时起作用。

Construct ObbsMsg: 0
waiting for msg
waiting for msg
waiting for msg
waiting for msg
waiting for msg
waiting for msg
Server Started...
waiting for msg
got data: hello world. Adding to work queue
Construct ObbsMsg: 1
Got msg: hello world <----- this is what I've been wanting to see!
Destruct ObbsMsg: 0
waiting for msg

Answer 1

回答我自己的问题。

看来问题出在g_work_queue的声明上。

在头文件中声明为：staticcurrent_queue <boost :: shared_ptr> g_work_queue;

似乎声明它为静态不是我想要做的。 显然，这为每个已编译的.o文件创建了一个单独的队列对象，并且显然创建了单独的锁等。

这解释了为什么当队列在同一个源文件中由使用者和生产者在同一个文件中进行操作时起作用的原因。 但是在不同文件中时，并不是因为线程实际上正在等待不同的对象。

因此，我像这样重新声明了工作队列。

-- workqueue.h --
extern concurrent_queue< boost::shared_ptr<Msg> > g_work_queue;

-- workqueue.cpp --
#include "workqueue.h"
concurrent_queue< boost::shared_ptr<Msg> > g_work_queue;

这样做可以解决问题。