Let me preface this with the note that the whole idea behind what I'm
trying to do is invoke an arbitrary function in a new thread, optionally
delaying the invocation by some number of milliseconds
That said,
----- threadrun.h -----
#ifndef _THREADRUN_H_
#define _THREADRUN_H_
#include
namespace Thread
{
void ThreadRun(boost::function const &job);
void ThreadDelayedRun(boost::function const &job, unsigned int
delay);
};
#endif
----- threadrun.h -----
----- threadrun.cpp -----
#include "threadrun.h"
static void DelayedRun(boost::function job, unsigned int delay)
{
Sleepms(delay); // Routine available elsewhere that simply sleeps for
delay ms
job();
}
namespace Thread
{
void ThreadRun(boost::function const &job)
{
boost::thread thr = boost::thread(job);
thr.detach(); // Not really necessary, but it does make it
explicit that we'll never wait for the thread to finish
}
void ThreadDelayedRun(boost::function const &job, unsigned int
delay)
{
boost::thread thr = boost::thread(boost::bind(DelayedRun, job, delay));
thr.detach(); // Not really necessary, but it does make it
explicit that we'll never wait for the thread to finish
}
};
----- threadrun.cpp -----
Use cases would be:
void myFunc(int a, int b)
{
...
}
int myFunc1(int a, int b)
{
...
return x
}
Thread::ThreadRun(boost::bind(myFunc, 1000, 17));
Thread::ThreadDelayedRun(boost::bind(myFunc1, 2000, 42), 5000);
This appears to work correctly, I'm currently using boost 1.54 - haven't
build 1.55 yet, but will do so in the near future. My only concern is the
second case where I have myFunc1() whose return type is int, yet in the
prototype for ThreadDelayedRun() I'm making it look a whole lot like it's
void.
The return type ultimately doesn't matter since this is specifically
designed to be a "fire and forget" system, which means that any return
value will be lost, there's no way for the invoking thread to recover it.
So, is there anything dangerous about what I'm doing?
