C++ condition_variable::wait方法代码示例

int main()
{
  {
    boost::unique_lock<boost::mutex> lk(mut);
    boost::thread t(f);
    BOOST_TEST(test1 == 0);
    while (test1 == 0)
      cv.wait(lk);
    BOOST_TEST(test1 != 0);
    test2 = 1;
    lk.unlock();
    cv.notify_one();
    t.join();
  }
  test1 = 0;
  test2 = 0;
  {
    boost::unique_lock<boost::mutex> lk(mut);
    boost::thread t(f);
    BOOST_TEST(test1 == 0);
    while (test1 == 0)
      cv.wait(lk);
    BOOST_TEST(test1 != 0);
    lk.unlock();
    t.join();
  }

  return boost::report_errors();
}

 void wait() {
     boost::unique_lock<boost::mutex> lock ( mutex_ );
     while ( count_ == 0 ) {
         condition_.wait ( lock );
     }
     --count_;
 }

int main( int argc, char* argv[] )
{
	TA_Base_Test::CBoostLogger BoostLogger;
	BOOST_LOG_FUNCTION();


	TA_Base_Test::CTestCase* pTestCase = new TA_Base_Test::CTestCase();

	if (1 == g_runAsServer)
	{
		pTestCase->runTestCase_ForServer();
	}
	else
	{
		pTestCase->runTestCase_ForClient();
	}
	//

	//sleep
	{	
		boost::mutex::scoped_lock lock(g_mutexMainRun);
		g_conditionMainRun.wait(lock);
	}

	delete pTestCase;
	pTestCase = NULL;


	return 0;
}

 void wait()
 {
     boost::mutex::scoped_lock lock(mutex_);
     while(!count_)
         condition_.wait(lock);
     --count_;
 }

void WorkManagerImpl::WaitForWork()
{
    boost::unique_lock<boost::mutex> lock(m_dispatchermutex);
    while(m_workreq <= 0) m_condition.wait(lock);
    m_workreq--;
    if(m_workreq < 0) m_workreq = 0;
}

	TaskPtr pull() {
		boost::unique_lock<boost::mutex> lock(_mutex);
		while (_running) {
			std::cout << "pull 0" << std::endl;
			if (!_tasks.empty()) {
				std::cout << "pull A" << std::endl;

				TaskPtr task = _tasks.front();
				_tasks.pop_front();
				return task;
			} else {
				std::cout << "pull B" << std::endl;
				_no_task.wait(lock);
				std::cout << "pull C" << std::endl;
			}
		}
		while (!_running) {
			std::cout << "pull 1" << std::endl;
			if (!_tasks.empty()) {
				std::cout << "pull D" << std::endl;
				TaskPtr task = _tasks.front();
				_tasks.pop_front();
				return task;
			} else {
				std::cout << "pull E" << std::endl;
				return TaskPtr();
			}
		}
		return TaskPtr();
	}

boost::shared_ptr< const MapsBuffer::MapsRgb > 
MapsBuffer::getFront(bool print)
{
  boost::shared_ptr< const MapsBuffer::MapsRgb > depth_rgb;
  {
    boost::mutex::scoped_lock buff_lock (bmutex_);
    while (buffer_.empty ())
    {
      if (is_done)
        break;
      {
        boost::mutex::scoped_lock io_lock (io_mutex);
              //std::cout << "No data in buffer_ yet or buffer is empty." << std::endl;
      }
      buff_empty_.wait (buff_lock);
    }
    depth_rgb = buffer_.front ();
    buffer_.pop_front ();
  }
  
  if(print)
    PCL_INFO("%d maps left in the buffer...\n", buffer_.size ());
  
  return (depth_rgb);
}

void displayThreadLoop()
{
	printf("started image display thread!\n");
	boost::unique_lock<boost::mutex> lock(openCVdisplayMutex);
	while(imageThreadKeepRunning)
	{
		openCVdisplaySignal.wait(lock);

		if(!imageThreadKeepRunning)
			break;

		while(displayQueue.size() > 0)
		{
			if(!displayQueue.back().autoSize)
			{
				if(openWindows.find(displayQueue.back().name) == openWindows.end())
				{
					cv::namedWindow(displayQueue.back().name, cv::WINDOW_NORMAL);
					cv::resizeWindow(displayQueue.back().name, displayQueue.back().img.cols, displayQueue.back().img.rows);
					openWindows.insert(displayQueue.back().name);
				}
			}
			cv::imshow(displayQueue.back().name, displayQueue.back().img);
			cv::waitKey(1);
			displayQueue.pop_back();
		}
	}
	cv::destroyAllWindows();
	openWindows.clear();

	printf("ended image display thread!\n");
}

    void consumeToLog()
    {
        while (true)
        {
            try
            {
                typename LogObject::SmartPtr logObj;
                {
                    boost::mutex::scoped_lock lock(_qMutex);

                    while (_queue.size() == 0)
                    {
                        if (_isStopping)
                        {
                            std::cout << " Stopping consumeToLog Thread. " << std::endl;
                            return;
                        }
                        _qCondVar.wait(lock);
                    }

                    // Get the entry
                    logObj = _queue.front();
                    _queue.pop();
                }
                printLogObject(logObj);
            }
            catch (const boost::thread_interrupted& err)
            {
                std::cout << " Log::consumeToLog() - Got Interrupt Signal. " << _queue.size() << std::endl;
            }
        }//while
    }

    void record_thread_loop(void)
    {
        int buffer_no = 0;

        /* open log file*/
        FILE *logfile = fopen("fwrite_thread_testlog.log","w");
        BOOST_REQUIRE_MESSAGE(logfile != NULL, "Could not open logfile!");

        boost::unique_lock<boost::mutex> lock(mutex);

        while(record_thread_running)
        {
            record_trigger.wait(lock);
            if(buffer_no < 2)
            {
                active_buffer = &string_buffer_2;
                fwrite(string_buffer_1.c_str(), sizeof(char), string_buffer_1.length(), logfile);
                string_buffer_1.clear();
                buffer_no = 2;
            }
            else
            {
                active_buffer = &string_buffer_1;
                fwrite(string_buffer_2.c_str(), sizeof(char), string_buffer_2.length(), logfile);
                string_buffer_2.clear();
                buffer_no = 1;
            }
        }
        fclose(logfile);
    }

void slave_thread(int id)
{
    printf("    +++ slave thread %d: starting\n", id);

    while (true)
    {
        boost::unique_lock<boost::mutex> lock(data_ready_mutex);
        while (!data_ready)
        {
            data_ready_cond.wait(lock);
        }
        data_ready = false;

        unsigned work_unit;
        {
            boost::lock_guard<boost::mutex> lock(work_queue_mutex);
            if (work_queue.size() == 0)
                abort();
            work_unit = work_queue.back();
            work_queue.pop_back();
        }
        printf("        slave thread %d: got work unit %u\n", id, work_unit);

        // Pretend to work
        boost::chrono::milliseconds sleepDuration(3);
        boost::this_thread::sleep_for(sleepDuration);
    }

    printf("    --- slave thread %d: finished\n", id);
}

static void status_paused_wait(Recog *recog, void *dummy) {

	boost::unique_lock<boost::mutex> lock(pause_mutex);

	pause_variable.wait(lock);

}

    void record_thread_loop(void)
    {
        int buffer_no = 0;
        std::ofstream logfile;

        /* open log file*/
        logfile.open ("stream_thread_testlog.log", ios::out);
        if (!logfile.is_open())
        {
            cout << "Could not open logfile!" << endl;
        }

        boost::unique_lock<boost::mutex> lock(mutex);

        while(datagen_thread_running)
        {
            record_trigger.wait(lock);
            if(buffer_no < 2)
            {
                active_buffer = &string_buffer_2;
                logfile << string_buffer_1;
                string_buffer_1.clear();
                buffer_no = 2;
            }
            else
            {
                active_buffer = &string_buffer_1;
                logfile << string_buffer_2;
                string_buffer_2.clear();
                buffer_no = 1;
            }
        }
        logfile.close();
    }

int main(int argc, char* argv[])
{
    if (argc < 3) {
        cout << "Usage: " << argv[0] << " <host> <port> [magic_bytes=0xd9b4bef9ul]" << endl
             << "  Pings a bitcoin-like node and gets the version information." << endl;
        return 0;
    }
    uint16_t port = strtoul(argv[2], NULL, 10);

    NetworkAddress address(NODE_NETWORK, DEFAULT_Ipv6, port);

    CoinNodeSocket nodeSocket;

    try {
        nodeSocket.open(MessageHandler, listener_network::MAGIC_BYTES, listener_network::PROTOCOL_VERSION, argv[1], port);
        nodeSocket.doHandshake(listener_network::PROTOCOL_VERSION, NODE_NETWORK, time(NULL), address, address, 0, "", 0);
        nodeSocket.waitOnHandshakeComplete();

        boost::unique_lock<boost::mutex> lock(mutex);
        while (!bGotVersion) gotVersion.wait(lock);
    }
    catch (const exception& e) {
        cout << e.what() << endl;
    }
}

bool PresentationEngineManager::startDocument( const std::string &file ) {
	LDEBUG( "PresentationEngineManager", "Start document: doc=%s", file.c_str() );

	if (formatter()) {
		_sys->enqueue( boost::bind( &PresentationEngineManager::stopDocument, this ) );
		{ //	Wait for compare
			boost::unique_lock<boost::mutex> lock( _stopMutex );
			while (!_stopped) {
				_stopWakeup.wait( lock );
			}
			_stopped = false;
		}

	}

	//	Init settings module
	player::settings::init();

	initFormatter( file );
	if (!formatter()->parseDocument()) {
		LWARN( "PresentationEngineManager", "parseDocument fail" );
		return false;
	}

	//	Play formatter
	_sys->enqueue( boost::bind( &FormatterMediator::play, formatter() ) );

	return true;
}