Thank you, that worked. I see what I was doing wrong.
One thing I don't understand about the alternative method...
boost::try_mutex::scoped_try_lock lock(mutex); // does a try_lock
while (!lock) {
cout << "trying...";
lock.try_lock();
}
How does "!lock" in the "while (!lock) { ... }" statement determine
whether it's true or false? Does it call a function in the
scoped_try_lock class? (sorry if that's a lame question...)
Hmmm... this doesn't seem to be documented very well. I'll have to fix
that. What it does is invoke operator void*() for a boolean test (this
mechanism also should be updated to use the safe_bool idiom as well).
Alternatively, you could call lock.locked() (which also appears to be
poorly documented). Thanks for pointing out these deficiencies.
William E. Kempf
Thanks for all you help. I have a few new questions now, though. ;) Again,
I'm a newbie to C++ so this may seem stupid...
I created a boost::thread object and even though it goes out of scope, the
thread continues to run. Also, when passing a class with the operator()
defined to boost::thread, it constructs and destructs the object several
times which seems odd. What I'm basically trying to do is run a thread,
have that thread lock a timed_mutex, then do its job. Then, in main, I try
to lock the same timed_mutex and if I can't get a lock before the time
expires, I need to terminate the thread. Below is the source code and the
output generated. My questions are below, after the output.
SOURCE:
#include <iostream>
#include
#include
#include
using namespace std;
boost::timed_mutex mutex;
class thread_class
{
public:
explicit thread_class(int sleep): _sleep(sleep) {};
void operator()()
{
boost::xtime xt;
cout << "thread: locking mutex\n";
boost::timed_mutex::scoped_timed_lock lock(mutex,true);
boost::xtime_get(&xt,boost::TIME_UTC);
cout << "thread: sleeping for " << _sleep << " seconds\n";
xt.sec += _sleep;
boost::thread::sleep(xt);
cout << "thread: freeing lock -- goodbye\n";
}
~thread_class() { cout << "thread_class destructed\n"; }
private:
int _sleep;
};
int main( void )
{
{
cout << "main: creating thread\n";
thread_class test(10);
boost::thread thrd(test);
cout << "main: sleeping for 2 seconds\n";
sleep(2);
cout << "main: trying to lock mutex -- waiting 5
seconds...\n";
boost::timed_mutex::scoped_timed_lock lock(mutex,false);
boost::xtime xt;
boost::xtime_get(&xt,boost::TIME_UTC);
xt.sec += 5;
if ( lock.timed_lock(xt) )
{
cout << "obtain lock -- joining thread\n";
thrd.join();
}
else
{
cout << "failed to obtain lock\n";
}
}
cout << "main: making sure thread is gone\n";
sleep(10);
return 0;
}
OUTPUT:
main: creating thread
thread_class destructed
thread_class destructed
thread_class destructed
thread_class destructed
main: sleeping for 2 seconds
thread: locking mutex
thread: sleeping for 10 seconds
main: trying to lock mutex -- waiting 5 seconds...
failed to obtain lock
thread_class destructed
main: making sure thread is gone
thread: freeing lock -- goodbye
thread_class destructed
1) Why are so many thread_class objects constructed/destructed when calling
boost::thread?
2) After the thread object (test) goes out of scope, why does the thread
continue to run? Is it copied when calling boost::thread and run detached
from the main thread?
3) Is there a way I can cancel a thread if going out of scope doesn't stop
it?
Thanks again,
James
Info: http://www.boost.org
Wiki: http://www.crystalclearsoftware.com/cgi-bin/boost_wiki/wiki.pl
Unsubscribe: mailto:boost-users-unsubscribe@yahoogroups.com
Your use of Yahoo! Groups is subject to http://docs.yahoo.com/info/terms/
