C++ MessageQueue::push_back方法代码示例

void SendIPCMessage(ipc_message_t msg, bool blocking) {
    MessageQueue* q = msg.ConsumableEarly() ? ipcEarlyMessageQueue : ipcMessageQueue;
    msg.blocking = blocking;

#ifdef IPC_DEBUG
    lk_lock(printing_lock, 1);
    std::cerr << "[SEND] IPC message, ID: " << msg.id << std::endl;
    lk_unlock(printing_lock);
#endif

    lk_lock(lk_ipcMessageQueue, 1);
    q->push_back(msg);

    if (blocking)
        ackMessages->operator[](msg) = false;
    lk_unlock(lk_ipcMessageQueue);

    if (blocking) {
        lk_lock(lk_ipcMessageQueue, 1);
        while (ackMessages->at(msg) == false) {
            lk_unlock(lk_ipcMessageQueue);
            xio_sleep(10);
            lk_lock(lk_ipcMessageQueue, 1);
        }
        lk_unlock(lk_ipcMessageQueue);
    }
}

void
RPCChannel::OnMessageReceivedFromLink(const Message& msg)
{
    AssertLinkThread();
    mMonitor->AssertCurrentThreadOwns();

    if (MaybeInterceptSpecialIOMessage(msg))
        return;

    // regardless of the RPC stack, if we're awaiting a sync reply, we
    // know that it needs to be immediately handled to unblock us.
    if (AwaitingSyncReply() && msg.is_sync()) {
        // wake up worker thread waiting at SyncChannel::Send
        mRecvd = msg;
        NotifyWorkerThread();
        return;
    }

    MessageQueue *queue = (msg.priority() == IPC::Message::PRIORITY_HIGH)
                          ? &mUrgent
                          : &mPending;

    bool compressMessage = (msg.compress() && !queue->empty() &&
                            queue->back().type() == msg.type() &&
                            queue->back().routing_id() == msg.routing_id());
    if (compressMessage) {
        // This message type has compression enabled, and the back of
        // the queue was the same message type and routed to the same
        // destination.  Replace it with the newer message.
        MOZ_ASSERT(queue->back().compress());
        queue->pop_back();
    }

    queue->push_back(msg);

    // There are three cases we're concerned about, relating to the state of
    // the main thread:
    //
    // (1) We are waiting on a sync reply - main thread is blocked on the IPC monitor.
    //   - If the message is high priority, we wake up the main thread to
    //     deliver the message. Otherwise, we leave it in the mPending queue,
    //     posting a task to the main event loop, where it will be processed
    //     once the synchronous reply has been received.
    //
    // (2) We are waiting on an RPC reply - main thread is blocked on the IPC monitor.
    //   - Always wake up the main thread to deliver the message.
    //
    // (3) We are not waiting on a reply.
    //   - We post a task to the main event loop.
    //
    bool waiting_rpc = (0 != StackDepth());
    bool urgent = (msg.priority() == IPC::Message::PRIORITY_HIGH);

    if (waiting_rpc || (AwaitingSyncReply() && urgent)) {
        // Always wake up our RPC waiter, and wake up sync waiters for urgent
        // messages.
        NotifyWorkerThread();
    } else {
        // Worker thread is either not blocked on a reply, or this is an
        // incoming RPC that raced with outgoing sync and needs to be deferred
        // to a later event-loop iteration.
        if (!compressMessage) {
            // If we compressed away the previous message, we'll reuse
            // its pending task.
            mWorkerLoop->PostTask(FROM_HERE, new DequeueTask(mDequeueOneTask));
        }
    }
}

/******************************* test functions *******************************/
int32_t ut_MessageQueue_simple(void)
{
	TestCaseBegin();

	std::mutex mMut;

	std::atomic_int mInt;
	mInt = 0;
	std::atomic_char running;
	running = 1;

	MessageQueue < std::function < int(void) >> messages;

	std::thread t1([&]
		{
			while(running)
			{
				const auto f = messages.receive();
				if(f) mInt = f();
				std::this_thread::sleep_for(std::chrono::milliseconds(10));
			}
		}
		);

	CHECK(0 == mInt);

	messages.push_back([ = ] {return 1; }
			   );
	std::this_thread::sleep_for(std::chrono::milliseconds(20));
	CHECK(1 == mInt);

	messages.push_back([ = ] {return 2; }
			   );
	std::this_thread::sleep_for(std::chrono::milliseconds(20));
	CHECK(2 == mInt);

	messages.push_back([ = ] {return 4; }
			   );
	messages.push_front([ = ] {return 3; }
			    );
	std::this_thread::sleep_for(std::chrono::milliseconds(5));
	CHECK(3 == mInt);
	std::this_thread::sleep_for(std::chrono::milliseconds(10));
	CHECK(4 == mInt);

	{
		std::lock_guard<std::mutex> lg(mMut);
		messages.push_back([ = ] {return 5; }
				   );
		messages.push_back([ = ] {return 5; }
				   );
		messages.push_back([ = ] {return 5; }
				   );
		messages.clear_and_push_front([ = ] {return 6; }
					      );
	}
	std::this_thread::sleep_for(std::chrono::milliseconds(20));
	CHECK(6 == mInt);
	std::this_thread::sleep_for(std::chrono::milliseconds(10));
	CHECK(6 == mInt);

	messages.push_back([ = ] {return 5; }
			   );
	running = 0;
	t1.join();

	TestCaseEnd();
}

int32_t ut_MessageQueue_complex(void)
{
	TestCaseBegin();

	std::mutex mMut;

	std::atomic_int mInt;
	mInt = 0;

	MessageQueue < std::pair < std::function<int(void)>, bool >> messages;

	std::thread t1([&]
		{
			while(true)
			{
				const auto f = messages.receive();
				if(f.second) break;
				if(f.first) mInt = f.first();
				std::this_thread::sleep_for(std::chrono::milliseconds(50));
			}
		}
		);

	CHECK(0 == mInt);

	messages.push_back(std::make_pair([ = ] {return 1; }, false));
	std::this_thread::sleep_for(std::chrono::milliseconds(100));
	CHECK(1 == mInt);

	messages.push_back(std::make_pair([ = ] {return 2; }, false));
	std::this_thread::sleep_for(std::chrono::milliseconds(100));
	CHECK(2 == mInt);

	messages.push_back(std::make_pair([ = ] {return 4; }, false));
	messages.push_back(std::make_pair([ = ] {return 5; }, false));
	messages.push_front(std::make_pair([ = ] {return 3; }, false));
	std::this_thread::sleep_for(std::chrono::milliseconds(40));
	CHECK(3 == mInt);
	std::this_thread::sleep_for(std::chrono::milliseconds(50));
	CHECK(4 == mInt);
	std::this_thread::sleep_for(std::chrono::milliseconds(50));
	CHECK(5 == mInt);


	{
		std::lock_guard<std::mutex> lg(mMut);
		messages.push_back(std::make_pair([ = ] {return 4; }, false));
		messages.push_back(std::make_pair([ = ] {return 4; }, false));
		messages.push_back(std::make_pair([ = ] {return 4; }, false));
		messages.clear_and_push_front(std::make_pair([ = ] {return 6; }, false));
	}
	std::this_thread::sleep_for(std::chrono::milliseconds(50));
	CHECK(6 == mInt);
	std::this_thread::sleep_for(std::chrono::milliseconds(50));
	CHECK(6 == mInt);

	messages.push_front(std::make_pair([ = ] {return 0xff; }, true));
	std::this_thread::sleep_for(std::chrono::milliseconds(10));
	t1.join();

	TestCaseEnd();
}