bool Worker::addProcessor(int id, Runnable *processor) { bool ret = false; std::map<int, Runnable*> runnables; Runnable* current; std::lock_guard<std::mutex> guard(mtx); while (!processors.empty()){ current = processors.top(); processors.pop(); runnables[current->getId()] = current; } if (runnables.count(id) == 0) { processor->setId(id); runnables[id] = processor; ret = true; } for (auto it : runnables){ processors.push(it.second); } return ret; }
bool Worker::removeProcessor(int id) { bool ret = false; std::map<int, Runnable*> runnables; Runnable* current; std::lock_guard<std::mutex> guard(mtx); while (!processors.empty()){ current = processors.top(); processors.pop(); runnables[current->getId()] = current; } while (runnables.count(id) > 0) { runnables.erase(id); ret = true; } for (auto it : runnables){ processors.push(it.second); } return ret; }
static void* execute_thread(void * ptr) { Runnable* runnable = static_cast<Runnable*>(ptr); assert(runnable); runnable->run(); pthread_exit(NULL); }
void AsyncTaskExecutor::run() { while(_isRunning) { std::unique_lock<std::mutex> lock(_mutex); if(!_queue.empty()) { Runnable *task = _queue.front(); _queue.pop_front(); if(task!=NULL) { _isBusy = true; _currentTask = task; lock.unlock(); task->run(); lock.lock(); _currentTask = NULL; if(task->toDelete()) delete task; } } else if(_isRunning) { _isBusy = false; _signal.wait(lock); } } return; }
//TODO: avoid void functions void Worker::getState(Jzon::Object &workerNode) { Jzon::Array pList; std::map<int, Runnable*> runnables; Runnable* current; { std::lock_guard<std::mutex> guard(mtx); while (!processors.empty()){ current = processors.top(); processors.pop(); runnables[current->getId()] = current; } for (auto it : runnables){ processors.push(it.second); } } for (auto it : runnables) { pList.Add(it.first); } workerNode.Add("type", utils::getWorkerTypeAsString(type)); workerNode.Add("processors", pList); }
Milliseconds RunLoop::Impl::processRunnables() { std::lock_guard<std::recursive_mutex> lock(mtx); auto now = Clock::now(); auto nextDue = TimePoint::max(); // O(N) but in the render thread where we get tons // of messages, the size of the list is usually 1~2. for (nextRunnable = runnables.begin(); nextRunnable != runnables.end();) { Runnable* runnable = *(nextRunnable++); auto const dueTime = runnable->dueTime(); if (dueTime <= now) { runnable->runTask(); } else { nextDue = std::min(nextDue, dueTime); } } if (runnables.empty() || nextDue == TimePoint::max()) { return Milliseconds(-1); } auto timeout = std::chrono::duration_cast<Milliseconds>(nextDue - now); if (alarm) { alarm->invoke(&Alarm::set, timeout); } return timeout; }
void RunnableHandler::handleEvent( void * e) { Runnable *r = reinterpret_cast< Runnable * > (e); r->run(); if( d_->del_ ) { delete r; } }
void *Thread_Unix::thread_main(void *data) { // kill thread immediately - no cancellation point pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, nullptr); Runnable *runnable = (Runnable *)data; ThreadLocalStorage tls; runnable->run(); return nullptr; }
void TaskExecutor::clearAll() { std::lock_guard<std::mutex> lock(_mutex); for(int i = 0; i < _queue.size(); i++) { Runnable *task = _queue[i]; if(task && task->toDelete()) delete task; } _queue.clear(); }
virtual void handleMessage(const Message& message) { switch (message.what) { case 4: case 5: { Runnable* runnable = (Runnable*) message.obj; runnable->run(); break; } default: Log::i(LOG_TAG, "Handler1::handleMessage 0x%x with ID %d by Looper 0x%x", &message, message.what, Looper::myLooper()); } }
void test_suite::func_begin(const std::string & name) { // Run test initializers const_it it = test_vec.find(name); if(it!=test_vec.end()) { (*it).second->begin(); return; } Runnable *pTest = new Runnable(name); test_vec.insert(pair<string,Runnable*>(name,pTest)); none_init_vec.push_back(pTest); pTest->begin(); }
void ThreadQueue::onStarted() { Runnable* r; // qDebug() << "has started"; while ((r = hasMore()) != NULL) { //qDebug() << "executing next from list" << r->name(); QVariant result = r->run(); emit finished(r, result); } thread()->quit(); }
/** 执行任务的工作线程。 当前没有任务时, 如果当前线程数量大于最小线程数量,减少线程, 否则,执行清理程序,将线程类给释放掉 **/ void CThreadPoolExecutor::CWorker::Run() { Runnable * pTask = NULL; while (m_bRun) { if (NULL == m_pFirstTask) { pTask = m_pThreadPool->GetTask(); } else { pTask = m_pFirstTask; m_pFirstTask = NULL; } if (NULL == pTask) { EnterCriticalSection(&(m_pThreadPool->m_csThreadPoolLock)); if (m_pThreadPool->GetThreadPoolSize() > m_pThreadPool->m_minThreads) { ThreadPoolItr itr = m_pThreadPool->m_ThreadPool.find(this); if (itr != m_pThreadPool->m_ThreadPool.end()) { m_pThreadPool->m_ThreadPool.erase(itr); m_pThreadPool->m_TrashThread.insert(this); } m_bRun = false; } else { ThreadPoolItr itr = m_pThreadPool->m_TrashThread.begin(); while (itr != m_pThreadPool->m_TrashThread.end()) { (*itr)->Join(); delete (*itr); m_pThreadPool->m_TrashThread.erase(itr); itr = m_pThreadPool->m_TrashThread.begin(); } } LeaveCriticalSection(&(m_pThreadPool->m_csThreadPoolLock)); continue; } else { pTask->Run(); pTask = NULL; } } }
void ChannelService::OnSoftSignal(uint32 soft_signo, uint32 appendinfo) { switch (soft_signo) { case CHANNEL_REMOVE: { //uint32 chanel_id = appendinfo; VerifyRemoveQueue(); break; } case WAKEUP: { Runnable* task = NULL; while (m_pending_tasks.Pop(task)) { if (NULL != task) { task->Run(); } } break; } case USER_DEFINED: { if (NULL != m_user_cb) { m_user_cb(this, appendinfo, m_user_cb_data); } break; } case CHANNEL_ASNC_IO: { ChannelAsyncIOContext ctx; while (m_async_io_queue.Pop(ctx)) { if (NULL != ctx.cb) { Channel* ch = GetChannel(ctx.channel_id); ctx.cb(ch, ctx.data); } } break; } default: { break; } } }
void TaskExecutor::executeAll() { std::lock_guard<std::mutex> lock(_mutex); while(!_queue.empty()) { Runnable *task = _queue.front(); _queue.pop_front(); if(task!=NULL) { task->run(); if(task->toDelete()) delete task; } } }
const SUCCESS loop() override { stringstream ss; switch(counter) { case NAME: ss<<"Window is titled "<<win->getName(); counter = POSITION; break; case POSITION: (ss<<"Window is at position ")<<win->getPosition(); counter = SIZE; break; case SIZE: ss<<"Window has dimensions "<<win->getSize(); counter = ID; break; case ID: ss<<"Window has ID "<<int(win->getID()); counter = STAHP; break; case STAHP: runner->stop(); break; default: return FAILED; } query = ss.str(); SDL_Delay(delay); return SUCCEEDED; }
LRESULT OnTaskHandleMsg(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/) { Runnable* pRunnable = (Runnable *)wParam; if (pRunnable) { pRunnable->Run(); if (pRunnable->IsBeHosted()) { pRunnable->Release(); } } return 0; }
/** * This method encapsulates the runnable. */ void *threadRunner(void *v) { pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL); Runnable *runnable = static_cast<Runnable*>(v); try { runnable->run(); } catch (string &s) { clog << "Exception caught at " << __FILE__ << ":" << __LINE__ << ": " << s << endl; throw; } catch (...) { clog << "Unknown exception caught at " << __FILE__ << ":" << __LINE__ << "." << endl; throw; } return NULL; }
void Widget::on_pushButton_clicked() { QList<QStandardItem *> row; QString taskName = QString("Task %1").arg(m_model->rowCount()); row << new QStandardItem(taskName) << new QStandardItem("queued"); m_model->appendRow(row); Runnable *runnable = new Runnable(taskName, this); runnable->setAutoDelete(true); QThreadPool::globalInstance()->start(runnable); if (m_model->rowCount() < 2) { int width(ui->tableView->contentsRect().width() - ui->tableView->verticalScrollBar()->width()); ui->tableView->setColumnWidth(0, width / 2); ui->tableView->setColumnWidth(1, width / 2); } }
void threadLogic() { try { while(!STOP_FLAG) { Runnable *runnable = workQueue.pull(); if(runnable != NULL) { runnable->run(); delete runnable; } } } catch(const boost::thread_interrupted&) { } };
/** * システムコールバック用エントリポイント * Mutex作成後にConstructorのcreateOnRunフラグ動作用のMutexを追加して * この関数内の頭に仕込んでおく必要があるな・・・ */ static void* CallbackDispatcher(void* DispatchKey) { PosixThread* This = reinterpret_cast<PosixThread*>(DispatchKey); assert(dynamic_cast<PosixThread*>(This) != NULL); // wait for start signal. ScopedLock<PosixMutex> lock(This->starter); int retValue = 0; { ScopedLock<PosixMutex> lock(This->statusSync); This->isRun = true; } try { Runnable* entry = This->getRunningTarget(); entry->prepare(); retValue = entry->run(); entry->dispose(); } catch (ThreadException& e) { This->transporter = new ThreadException(e); retValue = abort_by_exception; } catch (...) { This->transporter = new ThreadException("unknown exception."); retValue = abort_by_exception; } { ScopedLock<PosixMutex> lock(This->statusSync); This->isRun = false; } pthread_exit(reinterpret_cast<void*>(retValue)); return 0; }
void Worker::process() { Runnable* currentJob = NULL; std::unique_lock<std::mutex> guard(mtx); while(run && !processors.empty()) { currentJob = processors.top(); processors.pop(); guard.unlock(); currentJob->sleepUntilReady(); currentJob->runProcessFrame(); guard.lock(); processors.push(currentJob); } thread.detach(); }
Thread::Thread(Runnable &runnable, bool detached) : runnable_(&runnable), #ifndef _WIN32 thread_(0), #endif joined_(false), detached_(detached) { LOG_DEBUG("Thread::Thread("<< &runnable <<":"<< runnable.getName() <<")"); pthread_attr_init(&attr_); if (detached) { pthread_attr_setdetachstate(&attr_, PTHREAD_CREATE_DETACHED); } }
void Thread::Run::exec(void) { while (true) { // Execute runnable { Runnable* e; m.acquire(); e=r; r=NULL; m.release(); assert(e != NULL); e->run(); delete e; } // Put into idle stack Thread::m()->acquire(); n=Thread::idle; Thread::idle=this; Thread::m()->release(); // Wait for next runnable e.wait(); } }
void ThreadPoolImpl::Destroy() { if (!m_bCreate) { return; } do { //!should wait dead thread have been deleted. unsigned int nThread = 0, nTask = 0; this->Statistic(nThread, nTask); if (m_nMinThread == nThread && 0 == nTask) { break; } else { Thread::Sleep(10); } } while (1); TAutoLock lock(m_mtxThread); ThreadIterator itr = m_threads.begin(); while (itr != m_threads.end()) { //!should wait all thread have been done. Thread *pThread = (*itr); Runnable *pWorker = pThread->GetRunnable(); pWorker->Stop(); pThread->Join(); delete pThread; (*itr) = 0; m_threads.erase(itr); itr = m_threads.begin(); } //!now, there should be no task. assert(m_tasks.empty()); m_bCreate = false; }
void run() { while (true) { if (mRequest->isEmpty()) { cout << "exiting run()" << endl; return; } // Pull a runnable off the queue Runnable *handler; mRequest->dequeue(handler); // Run the runnable that we pulled off the queue handler->run(); // Delete the runnable we pulled off the queue delete handler; } }
VOID Thread::__thr_run (VOID * arg) { // Get the thread object, and update its remaining attributes. Thread * thr = reinterpret_cast <Thread *> (arg); // Set the current thread to the Thread object. This allows the // client to access the Thread object via the current () method. Thread::current_.set (thr->thr_id_, thr); do { Write_Guard <RW_Mutex> guard (thr->rw_mutex_); thr->os_thr_id_ = PIN_GetTid (); thr->parent_os_thr_id_ = PIN_GetParentTid (); // Set the state to running. thr->state_ = RUNNING; } while (0); // Determine what run method we should invoke. Either we invoke the run() // method on the runnable_ object contained in the thread, or we invoke // the run() method on the thread. The runnable_ variable takes precedence // over the run() method on the Thread. Runnable * runnable = thr->runnable_; if (0 == runnable) runnable = thr; runnable->run (); do { // Reset the thread state. Write_Guard <RW_Mutex> guard (thr->rw_mutex_); thr->state_ = TERMINATED; } while (0); }
void LinkageWorker::OnCommand() { std::list<Runnable *> q; MutexLocker locker(_mutex); q.swap(_commands); locker.Unlock(); for (std::list<Runnable *>::iterator p = q.begin(); p != q.end(); ++p) { Runnable *command = *p; if (!command) { ev_break(_loop, EVBREAK_ALL); _quit = true; return; } if (!command->Run()) { break; } } for (std::list<Runnable *>::iterator p = q.begin(); p != q.end(); ++p) { delete *p; } }
const SUCCESS loop() override { SDL_SetRenderDrawColor(ren->getRenderer(), 255, 0, 0, 0); SUCCESS ret = SUCCEEDED; for(auto i = points.begin(); i != current; i++) { ret |= SDL_RenderDrawLine(ren->getRenderer(), i->x(), i->y(), (i+1)->x(), (i+1)->y()); } if(++current == points.end()) ender->stop(); SDL_SetRenderDrawColor(ren->getRenderer(), 0, 0, 0, 0); return ret; }
void PooledThread::run() { _started.set(); for (;;) { _targetReady.wait(); _mutex.lock(); if (_pTarget) // a NULL target means kill yourself { _mutex.unlock(); try { _pTarget->run(); } catch (Exception& exc) { ErrorHandler::handle(exc); } catch (std::exception& exc) { ErrorHandler::handle(exc); } catch (...) { ErrorHandler::handle(); } FastMutex::ScopedLock lock(_mutex); _pTarget = 0; #if defined(_WIN32_WCE) && _WIN32_WCE < 0x800 _idleTime = wceex_time(NULL); #else _idleTime = time(NULL); #endif _idle = true; _targetCompleted.set(); ThreadLocalStorage::clear(); _thread.setName(_name); _thread.setPriority(Thread::PRIO_NORMAL); } else { _mutex.unlock(); break; } } }