Re: boost.thread - class derivated from thread

On Feb 11, 1:07 pm, Lars Uffmann <a...@nurfuerspam.de> wrote:


Yes, but this may have unintentional implications with regards
to the thread state. (This "feature" is probably the biggest
defect in Boost threads. But it's easy to work around.)

You should decide, up front, at creation, whether you want to
use joinable threads, or detached threads. (From what you've
described so far, it sounds like joinable.) In Boost (at least
the last version I looked at), destructing the creating thread
object before having joined makes the thread detached. If you
want a detached thread, just write a small function which you
call to start it---the boost::thread object is a local variable
in the function, and will be destructed when you return from the
function. If you want joinable threads, I'd wrap the thread
class in my own thread class, which would probably cause an
assertion failure if the destructor was called before the thread
was joined.

In your case, I think you probably should allocate the wrapped
thread dynamically; when you get the command to terminate it,
you do whatever is necessary so that it terminates, then join,
and only then delete the wrapped thread object (which in turn
would delete the boost::thread).

Alternatively, if you really only want a single thread, which
stops and starts, you should probably use boost::condition,
e.g.:

    // in class, of course...
    boost::mutex myMutex ;
    boost::condition myCond ;
    bool myIsActive ;

    // called by external thread...
    void activate()
    {
        boost::mutex::scoped_lock
                            l( myMutex ) ;
        myIsActive = true ;
        myCond.notify_all() ;
    }

    void deactivate()
    {
        boost::mutex::scoped_lock
                            l( myMutex ) ;
        myIsActive = false ;
        // do something to trigger passage through
        // checkActivate() (send empty message, etc.)?
        // This part could actually occur after the lock has
        // been released.
    }

    // called by the thread itself, from time to time
    void checkActivate()
    {
        boost::mutex::scoped_lock
                            l( myMutex ) ;
        while ( ! myIsActive ) {
            myCond.wait( l ) ;
        }
    }

--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
                   Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34