void operator()()
{
boost::posix_time::seconds workTime(1);
std::cout << "Worker: running during one second..." << std::endl;
boost::this_thread::sleep(workTime);
std::cout << "Worker: finished" << std::endl;
}
// -------------------------------------------------------------------
// InThread
// -------------------------------------------------------------------
void ThreadManager::InThread()
{
boost::posix_time::milliseconds workTime(5);
while (running)
{
boost::this_thread::sleep(workTime);
if (running == false) break;
if (!inHasQueuedItems) continue;
boost::shared_ptr<map<string, boost::shared_ptr<void> > > item;
inQueueLocker.lock();
while (inThreadQueue->size() > 0)
{
item = inThreadQueue->front();
inThreadQueue->pop_front();
ProcessItem(item);
item->clear();
}
inHasQueuedItems = false;
inQueueLocker.unlock();
}
}
void ThreadManager::tryJoin()
{
for(;;)
{
boost::posix_time::milliseconds workTime(150);
boost::this_thread::sleep(workTime);
_mute.lock();
if (_currentThreads.size()>0)
{
for (std::vector<boost::thread*>::iterator it = _currentThreads.begin() ; it != _currentThreads.end() ; it++)
{
if(!(*it))
{
_mute.lock();
std::cout << "Attention !!!" << std::endl;
boost::posix_time::seconds workTime(120);
boost::this_thread::sleep(workTime);
_currentThreads.erase(it);
it--;
_mute.unlock();
}
_mute.unlock();
if ((*it)->timed_join(boost::posix_time::milliseconds(10)))
{
_mute.lock();
std::cout << "thread terminated" << std::endl;
delete *it;
_currentThreads.erase(it);
it--;
_mute.unlock();
}
_mute.lock();
}
}
else if(!_check) break;
_mute.unlock();
}
_mute.lock();
_check=1;
_mute.unlock();
}
void
H264AVCEncoderTest::testThread(int view,UInt uiFrame, UInt uiMaxFrame,UInt uiLayer,UInt auiPicSize, UInt uiWrittenBytes, int v7, int v8){
printf("prova de thread %d\n",view);
boost::posix_time::milliseconds workTime(2000);
//printf("Dades\nview: %d\tuiFrame: %d\tuiMaxFrame: %d\tuiLayer: %d\tuiPicSize: %d\tuiWrittenBytes: %d\n",view,uiFrame, uiMaxFrame, uiLayer, auiPicSize, uiWrittenBytes);
boost::this_thread::sleep(workTime);
printf("Final de thread %d\n",view);
}
void Application::Poll()
{
DoApplicationEvents();
DoChatEvents();
DoSceneEvents();
DoAudioEvents();
boost::posix_time::milliseconds workTime(100);
boost::this_thread::sleep(workTime);
}
void operator()()
{
while (true)
{
std::cout << "calling callback\n";
callback_();
boost::posix_time::seconds workTime(3);
boost::this_thread::sleep(workTime);
game_.MakeMove(1.0);
}
}
void workerFunc()
{
boost::posix_time::seconds workTime(3);
std::cout << "Worker: running" << std::endl;
// Pretend to do something useful...
boost::this_thread::sleep(workTime);
std::cout << "Worker: finished" << std::endl;
}
void func1() {
std::cout << "func1" << std::endl;
while(1) {
boost::recursive_mutex &lock = getLock();
lock.lock();
boost::posix_time::seconds workTime(1);
boost::this_thread::sleep(workTime);
lock.unlock();
printf("thread 1 running..\n");
}
}
void workerFunc()
{
std::cout << "Worker: running" << std::endl;
int res;
MoveStateDeferred *move_state_deferred;
MoveServerPacket *move_server_packet;
MoveServerCameraFrameSlicePacket *move_server_camera_frame_slice_packet;
move_state_deferred = (MoveStateDeferred *)malloc(sizeof(MoveStateDeferred));
move_server_packet = (MoveServerPacket *)malloc(sizeof(MoveServerPacket));
move_server_camera_frame_slice_packet = (MoveServerCameraFrameSlicePacket *)malloc(sizeof(MoveServerCameraFrameSlicePacket));
move_state_deferred->update_success = updateSuccess;
move_state_deferred->update_failure = updateFailure;
move_state_deferred->update_camera_success = updateCameraSuccess;
move_state_deferred->update_camera_failure = updateCameraFailure;
move_state_deferred->move_server_packet = move_server_packet;
move_state_deferred->move_server_camera_frame_slice_packet = move_server_camera_frame_slice_packet;
// Connect
res = serverConnect("192.168.1.14", "7899", move_state_deferred);
ROS_ERROR("connect: %d", res);
while(1)
{
io_mutex.lock();
if(ros_down)
break;
io_mutex.unlock();
boost::posix_time::millisec workTime(3);
// Pretend to do something useful...
boost::this_thread::sleep(workTime);
}
io_mutex.unlock();
// Disconnect
res = serverDisconnect();
ROS_ERROR("disconnect: %d", res);
// Free heap
free(move_state_deferred);
free(move_server_packet);
free(move_server_camera_frame_slice_packet);
std::cout << "Worker: finished" << std::endl;
}
void watch(unsigned sleepMillis)
{
//float ms = N * 1e3;
boost::posix_time::milliseconds workTime(sleepMillis);
while (running) {
std::cout << "Watchdog: started, will sleep for "
<< sleepMillis << "ms"
<< std::endl;
boost::this_thread::sleep(workTime);
// now do some watching....
}
std::cout << "Watchdog: completed" << std::endl;
}
void processQueue(unsigned N)
{
float ms = N * 1e3;
boost::posix_time::milliseconds workTime(ms);
// std::cout << "Worker: started, will work for "
// << ms << "ms"
// << std::endl;
// We're busy, honest!
boost::this_thread::sleep(workTime);
// std::cout << "Worker: completed" << std::endl;
}
void ThreadManager::waitTheEnd()
{
_mute.lock();
_check=0;
_mute.unlock();
std::cout << "Wait The End" << std::endl;
for(;;)
{
boost::posix_time::seconds workTime(10);
boost::this_thread::sleep(workTime);
if (_testThread->timed_join(boost::posix_time::milliseconds(100))) break;
}
}
void func0() {
std::cout << "func0" << std::endl;
while(1) {
boost::recursive_mutex &lock = getLock();
lock.lock();
boost::posix_time::seconds workTime(3);
boost::this_thread::sleep(workTime);
// boost::xtime xt;
// boost::xtime_get(&xt, boost::TIME_UTC);
// xt.nsec += 3000000000;
// boost::thread::sleep(xt);
lock.unlock();
printf("thread 0 running..\n");
}
}
void ProgressMonitor::run() {
cout << clear_to_eos;
while (active()) {
cout << show_cursor( FALSE );
boost::mutex::scoped_lock l(mutex);
unsigned maxLength = 0;
for (unsigned u = 0; u < ProgressBars.size(); u++)
maxLength = maxLength < ProgressBars[u]->title.size() ? ProgressBars[u]->title.size() : maxLength;
cout << cursor_up(eraseLines);
for (unsigned u = 0; u < ProgressBars.size(); u++) {
cout << setw(maxLength + 1) << setfill(' ') << left << ProgressBars[u]->title << ": " << progressString(
ProgressBars[u]) << endl;
}
eraseLines = ProgressBars.size();
boost::posix_time::seconds workTime(1);
boost::this_thread::sleep(workTime);
}
cout << finalize;
}
void threadLog()
{
boost::posix_time::seconds workTime(1);
boost::this_thread::sleep(workTime);
boost::thread::id tId = boost::this_thread::get_id();
LOG_MSG << fmt("% %") % "Thread" % tId;
LOG_MSG << "Hello" << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8;
boost::this_thread::sleep(workTime);
LOG_MSG << fmt("% %") % "2 Thread" % tId;
boost::posix_time::milliseconds mTime(rand()*100000/RAND_MAX);
for (int i = 0; i < 100; i++)
{
LOG_MSG << fmt("%: % % %") % tId % i % (i*2) % (i*4);
boost::this_thread::sleep(mTime);
}
}
HRESULT CShdrEchoInstance::Cycle()
{
double delay;
while(_state==Running)
{
OutputTokens(); // this parses a line of shdr
std::string info = _backend->UpdatedShdrString(localvalues);
if(!info.empty())
EchoShdr(info.c_str());
localvalues=_backend->_values;
GetNextTokens();
// That's it all done for now. Have to start again.
if(tokens.size() < 1)
break;
intime = GetDateTime(tokens[0]);
/* if(intime.GetStatus() != valid)
{
intime=lasttime;
}*/
if(lasttime.m_dt == 0.0)
lasttime=intime;
diff= (intime-lasttime);
::AtlTrace("Diff = %f\n", diff.GetTotalSeconds());
delay = diff.GetTotalSeconds() * 1000;
delay = delay * 100.0/ _dOverride;
if(delay<1)
delay=10;
lasttime=intime;
boost::posix_time::milliseconds workTime((int) delay);
boost::this_thread::sleep(workTime);
}
_state=Ready;
return 0;
}
void Settings::setWorkTimeMin(int min)
{
m_settings->setValue(WORKTIMEMIN_NAME, QVariant(min));
emit workTimeChanged(workTime());
}
void Settings::setWorkTimeSec(int sec)
{
m_settings->setValue(WORKTIMESEC_NAME, QVariant(sec));
emit workTimeChanged(workTime());
}
