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

    void run() {
        while (1) {

            unique_lock<mutex> sqlLock(sqlMutex);
            cout << this_thread::get_id() << ": waiting until sqlQueue is NOT empty " << sqlQueue.size() << endl;
            sqlCond.wait(sqlLock, []{ return !sqlQueue.empty(); } );
            string sql = sqlQueue.front();
            sqlQueue.pop();
            sqlLock.unlock();

            cout << this_thread::get_id() << ": working on sql=" << sql << endl;
            string res = "";
            if (0 != exec(sql, res)) {
                cout << this_thread::get_id() << ": failed with error=" << m_error << endl;
                res = "failed with error="+m_error;
            }
            
            unique_lock<mutex> resultLock(resultMutex);
            cout << this_thread::get_id() << ": setting result to resultQueue, now size=" << resultQueue.size() << endl;
            resultQueue.emplace(res);
            resultLock.unlock();
            resultCond.notify_one();

        }
    }

void conn_get(tcp::iostream *&stream) {
#if USE_CONN_POOL
    {
        unique_lock<mutex> lock(_conn_mutex);
        while (_conns.size() == 0 && _n_conn_alloc >= CONN_MAX) {
            _conn_avail_cv.wait(lock);
        }

        if (_conns.size() > 0) {
            stream = _conns.back();
            _conns.pop_back();
        } else if (_n_conn_alloc < CONN_MAX) {
            ++ _n_conn_alloc;
            stream = new tcp::iostream();
            lock.unlock();
            stream->connect("127.0.0.1", "1481");
        }
    }
#else
    _conn_mutex.lock();
    if (_fb_conn == NULL) {
        _fb_conn = new tcp::iostream();
        _fb_conn->connect("127.0.0.1", "1481");
    }
    stream = _fb_conn;
#endif    
}

int main() {
	
		thread t1(erzeuger1);
		thread t2(erzeuger2);
		thread t3(verbraucher);
		thread t4(watcher);
	
	unique_lock<mutex> sperre2(m);
		cout << "\n";
		condivar.notify_one();
		condivar.wait(sperre2);

		

		//t1.detach();		mit detach wird der thread asugeführt ohen berücksichtigung der anderer Threads


		t1.join();
		t2.join();		//mit join() wird gewartet
		t3.join();
		t4.join();
		
		system("PAUSE");
	
	
}

void worker( void )
{
    while( true ){
        int data;
        {
            // unique_lockではコンストラクタでロックを取得し、デストラクタでロックを解除する。
            // また、明示的にロック、アンロックが可能である。
            unique_lock<mutex> lk(queue_mutex);
            // キューにデータがない場合はキューにデータが追加されたことが
            // 通知されるまで待つ。CPUを余分に消費することがない。
            while( v_queue.empty() ){
                // waitを呼ぶ前にはlkがロック状態でなければならない。
                // C++11でもspurious wakeupの問題があることに注意。
                // ここでready_cond.notify_one()が呼ばれるまでブロックする。
                // ready_cond.notify_one()が呼ばれると、再びロックを取得した状態で、この関数から抜ける。
                ready_cond.wait(lk);
            }
            //
            data = v_queue.front();
            v_queue.pop();
        }
        lock_guard<mutex> l(print_mutex);
        printf( "%p %d\n", this_thread::get_id(), data );
        fflush( stdout );
    }
}

void work(int serial, int &value, condition_variable &c, mutex &m, int &turn)
{
    while (1) {
        {
            unique_lock w{m};
            // ожидаем наступления события turn == serial
            c.wait(w, [&turn, &serial]() { return turn == serial; });
        }

        if (value >= 1000) {
            lock_guard w{m};
            turn = (turn + 1) % 2;
            c.notify_all();
            break;
        }
        cout << serial <<  " " << value << endl;
        ++value;

        {
            lock_guard w{m};
            turn = (turn + 1) % 2;
            c.notify_all();
        }
    }
}

    void WriteLock() {
        unique_lock<mutex> lk(mtx);
        writerQ.wait(lk, [this] { return !(is_writing || readers > 0); } );
        is_writing = true;

        lk.unlock();
    }

	static void filter()
	{
		size_t filterCount = 0;
	
		for (;;) {
			unique_lock<mutex> filterLock(sync);

			step2Condition.wait(filterLock, []() {return !nums.empty() || count == NUM_COUNT; });
			if (nums.empty()) {
				break;
			}

			int front = nums.front();
			if (front % 3 != 0 && front % 13 != 0) {
				filteredNums.push_back(front);
				filterCount++;
			}
			nums.erase(nums.begin(), nums.begin() + 1);

			filterLock.unlock();
		}
		step3Condition.notify_all();

		// Print trace of consumption
		//lock_guard<mutex> out(print);
		//cout << "Step 2 thread done -- filtered: " << filterCount << endl;
	}

	static void output(size_t remainderBase)
	{
		// Create out file
		ofstream outF("output" + to_string(remainderBase) + ".txt");

		size_t outputCount = 0;

		for (;;) {

			// Get lock for sync mutex; Wait for step 2
			unique_lock<mutex> outputLock(sync);
			if (filteredNums.empty()) break;
			step3Condition.wait(outputLock, []() {return !filteredNums.empty(); });
			if (filteredNums.empty()) break;

			// Get modulus
			if (!filteredNums.empty() && filteredNums[0] % FILE_FILTER_COUNT == remainderBase) {
				// Write to file
				outputCount++;
				outF << filteredNums[0] << endl;
				filteredNums.erase(filteredNums.begin(), filteredNums.begin() + 1);
			}

			outputLock.unlock();
		}

		// print stuff
		lock_guard<mutex> out(print);
		cout << "Group " << remainderBase << " has " << outputCount << " numbers" << endl;
	}

bool EnterStepping(std::function<void()> callback) {
	lock_guard guard(pauseLock);
	if (coreState != CORE_RUNNING && coreState != CORE_NEXTFRAME) {
		// Shutting down, don't try to step.
		return false;
	}
	if (!gpuDebug) {
		return false;
	}

	gpuDebug->NotifySteppingEnter();

	// Just to be sure.
	if (pauseAction == PAUSE_CONTINUE) {
		pauseAction = PAUSE_BREAK;
	}
	isStepping = true;

	callback();

	do {
		RunPauseAction();
		pauseWait.wait(pauseLock);
	} while (pauseAction != PAUSE_CONTINUE);

	gpuDebug->NotifySteppingExit();
	isStepping = false;
	return true;
}

void pub_func(const po::variables_map vm) {
	context_t ctxt(1);
	socket_t pub(ctxt, ZMQ_PUB);
	zmq_socket_monitor(pub, "inproc://monitor.pub", ZMQ_EVENT_ALL);
	thread monitor_thread(monitor_func, ref(ctxt), "inproc://monitor.pub", "pub", ref(pubDoneFlag));
	std::string payload(vm["size"].as<size_t>(), '.');
	if (vm.count("no-linger")) {
		int linger = 0;
		pub.setsockopt(ZMQ_LINGER, &linger, sizeof(linger));
	}
	if (vm.count("sndhwm")) {
		auto sndhwm = vm["sndhwm"].as<int>();
		pub.setsockopt(ZMQ_SNDHWM, &sndhwm, sizeof(sndhwm));
	}
	pub.bind("tcp://*:4404");
	{
		unique_lock<mutex> lock(subReadyMutex);
		while(subReadyFlag == false)
			subReadyCond.wait(lock);
	}
	for(size_t pubCount=0; pubCount<vm["count"].as<size_t>(); ++pubCount) {
		for(size_t partNo=1; partNo<vm["parts"].as<size_t>(); ++partNo)
			assert(pub.send(payload.data(), payload.size(), ZMQ_SNDMORE)==payload.size());
		assert(pub.send(payload.data(), payload.size())==payload.size());
	}
	this_thread::sleep_for(chrono::seconds(vm["recovery-time"].as<long>()));
	for(size_t pubCount=0; pubCount<vm["recovery-count"].as<size_t>(); ++pubCount) {
		if (vm["recovery-rate"].as<size_t>() > 0)
			this_thread::sleep_for(chrono::milliseconds(1000/vm["recovery-rate"].as<size_t>()));
		pub.send("bye", 3);
	}
	pubDoneFlag = true;
	monitor_thread.join();
}

void showID(int ID)
{
    unique_lock<mutex> lck(mtx);
	while (!ready) cv.wait(lck);
	// 3 2 1 GO!
	scout<<"Thread #"<<ID<<endl;
}

    //! Dequeues log record from the queue, blocks if no log records are ready to be processed
    bool dequeue_ready(record_view& rec)
    {
        unique_lock< mutex_type > lock(m_mutex);
        while (!m_interruption_requested)
        {
            if (!m_queue.empty())
            {
                const boost::log::aux::timestamp now = boost::log::aux::get_timestamp();
                enqueued_record const& elem = m_queue.top();
                const uint64_t difference = (now - elem.m_timestamp).milliseconds();
                if (difference >= m_ordering_window)
                {
                    // We got a new element
                    rec = elem.m_record;
                    m_queue.pop();
                    return true;
                }
                else
                {
                    // Wait until the element becomes ready to be processed
                    m_cond.timed_wait(lock, posix_time::milliseconds(m_ordering_window - difference));
                }
            }
            else
            {
                // Wait for an element to come
                m_cond.wait(lock);
            }
        }
        m_interruption_requested = false;

        return false;
    }

 void pop(T &result)
 {
     unique_lock<mutex> u(m);
     c.wait(u, [&] {return !q.empty();} );
     result = move_if_noexcept(q.front());
     q.pop();
 }

		vector<T> get_all() {
			unique_lock<mutex> l(cv_m);
			cv.wait(l, [this](){return count(this->v.begin(), this->v.end(), T()) == 0;});
			vector<T> ret = v;
			fill(v.begin(), v.end(), T());
			return ret;
		}

		T get(size_t k) {
			unique_lock<mutex> l(cv_m);
			cv.wait(l, [this, k](){return this->v[k] != T();});
			T t = v[k];
			v[k] = (T)0;
			return t;
		}