void SendJsonFileName(const std::vector<std::string> & filename) { int i; for(i=0; i<filename.size(); i++) { jsonsemp.wait(); jsonmutex.lock(); Qjson.push(filename[i]); jsonmutex.unlock(); jsonsemc.post(); statelog.write("Client Send Jsonfile %s\n", filename[i].c_str()); statelog.flush(); } }
void hashBlogId(std::vector<std::string> & _return, const std::vector<std::string> & inids) { MyStr ms; int ret; for(int i=0; i<inids.size(); i++) { ms.init(inids[i]); hashmutex.lock(); ret=hf.putKey(ms); hashmutex.unlock(); if(ret) { _return.push_back(inids[i]); } } }
inline bool interprocess_condition::do_timed_wait(bool tout_enabled, const boost::posix_time::ptime &abs_time, interprocess_mutex &mut) { boost::posix_time::ptime now = microsec_clock::universal_time(); if(tout_enabled){ if(now >= abs_time) return false; } typedef boost::interprocess::scoped_lock<interprocess_mutex> InternalLock; //The enter interprocess_mutex guarantees that while executing a notification, //no other thread can execute the do_timed_wait method. { //--------------------------------------------------------------- InternalLock lock; if(tout_enabled){ InternalLock dummy(m_enter_mut, abs_time); lock = detail::move_impl(dummy); } else{ InternalLock dummy(m_enter_mut); lock = detail::move_impl(dummy); } if(!lock) return false; //--------------------------------------------------------------- //We increment the waiting thread count protected so that it will be //always constant when another thread enters the notification logic. //The increment marks this thread as "waiting on interprocess_condition" detail::atomic_inc32((boost::uint32_t*)&m_num_waiters); //We unlock the external interprocess_mutex atomically with the increment mut.unlock(); } //By default, we suppose that no timeout has happened bool timed_out = false, unlock_enter_mut= false; //Loop until a notification indicates that the thread should //exit or timeout occurs while(1){ //The thread sleeps/spins until a interprocess_condition commands a notification //Notification occurred, we will lock the checking interprocess_mutex so that while(detail::atomic_read32(&m_command) == SLEEP){ detail::thread_yield(); //Check for timeout if(tout_enabled){ now = microsec_clock::universal_time(); if(now >= abs_time){ //If we can lock the interprocess_mutex it means that no notification //is being executed in this interprocess_condition variable timed_out = m_enter_mut.try_lock(); //If locking fails, indicates that another thread is executing //notification, so we play the notification game if(!timed_out){ //There is an ongoing notification, we will try again later continue; } //No notification in execution, since enter interprocess_mutex is locked. //We will execute time-out logic, so we will decrement count, //release the enter interprocess_mutex and return false. break; } } } //If a timeout occurred, the interprocess_mutex will not execute checking logic if(tout_enabled && timed_out){ //Decrement wait count detail::atomic_dec32((boost::uint32_t*)&m_num_waiters); unlock_enter_mut = true; break; } else{ //Notification occurred, we will lock the checking interprocess_mutex so that //if a notify_one notification occurs, only one thread can exit //--------------------------------------------------------------- InternalLock lock; if(tout_enabled){ InternalLock dummy(m_check_mut, abs_time); lock = detail::move_impl(dummy); } else{ InternalLock dummy(m_check_mut); lock = detail::move_impl(dummy); } if(!lock) return false; //--------------------------------------------------------------- boost::uint32_t result = detail::atomic_cas32 ((boost::uint32_t*)&m_command, SLEEP, NOTIFY_ONE); if(result == SLEEP){ //Other thread has been notified and since it was a NOTIFY one //command, this thread must sleep again continue; } else if(result == NOTIFY_ONE){ //If it was a NOTIFY_ONE command, only this thread should //exit. This thread has atomically marked command as sleep before //so no other thread will exit. //Decrement wait count. unlock_enter_mut = true; detail::atomic_dec32((boost::uint32_t*)&m_num_waiters); break; } else{ //If it is a NOTIFY_ALL command, all threads should return //from do_timed_wait function. Decrement wait count. unlock_enter_mut = 1 == detail::atomic_dec32((boost::uint32_t*)&m_num_waiters); //Check if this is the last thread of notify_all waiters //Only the last thread will release the interprocess_mutex if(unlock_enter_mut){ detail::atomic_cas32((boost::uint32_t*)&m_command, SLEEP, NOTIFY_ALL); } break; } } } //Unlock the enter interprocess_mutex if it is a single notification, if this is //the last notified thread in a notify_all or a timeout has occurred if(unlock_enter_mut){ m_enter_mut.unlock(); } //Lock external again before returning from the method mut.lock(); return !timed_out; }