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;
}
