How long should last a thread???

On Dec 1, 12:01 pm, christian.si... @gmail.com wrote:

Hello,

I need a buffer reinitialized approx. once in each second (I think
this is quite often). Now I think to do the reinit within a separate
thread (I am using boost::thread). Well, filling the buffer is a real
short task but must be done very often (at least once in a second).

So what is the guide line how often a thread should be created and how
long it should last???

Have you read about thread pools? An application that uses
such a pool will reuse threads over it's lifetime.

Your post though, could be improved with more detail/context
and I would consider posting it on comp.programmin g.threads
or Boost Users newsgroup.

Brian Wood
Ebenezer Enterprises
www.webebenezer.net

<ch************ *@gmail.comwrot e in message
news:08******** *************** ***********@e23 g2000prf.google groups.com...

Hello,

I need a buffer reinitialized approx. once in each second (I think
this is quite often). Now I think to do the reinit within a separate
thread (I am using boost::thread). Well, filling the buffer is a real
short task but must be done very often (at least once in a second).

So what is the guide line how often a thread should be created and how
long it should last???

This is really off-topic here, as the question has nothing to do with C++.

However, the short answer to your question is, it all depends on the
application.

Generally speaking, create a thread only if it is necessary. Thread
creation can be an expensive operation in terms of time, so creating a
thread every second *could* affect your application's performance, depending
on what it is doing. It sounds to me like the easiest thing to do would be
to create just one thread when the program starts up, and let that thread
run in an infinite loop in which it does the re-init and then goes to sleep
for one second on each iteration. That would allow it to re-initialize your
buffer every second as you want, without the need for creating/destroying a
new thread every time.

- Dennis

On Dec 1, 7:57 pm, "Dennis Jones" <nos...@nospam. comwrote:

<christian.si.. .@gmail.comwrot e in message

news:08******** *************** ***********@e23 g2000prf.google groups.com...

I need a buffer reinitialized approx. once in each second (I think
this is quite often). Now I think to do the reinit within a separate
thread (I am using boost::thread). Well, filling the buffer is a real
short task but must be done very often (at least once in a second).

So what is the guide line how often a thread should be created and how
long it should last???

This is really off-topic here, as the question has nothing to do with C++.

However, the short answer to your question is, it all depends on the
application.

Generally speaking, create a thread only if it is necessary. Thread
creation can be an expensive operation in terms of time, so creating a
thread every second *could* affect your application's performance, depending
on what it is doing. It sounds to me like the easiest thing to do would be
to create just one thread when the program starts up, and let that thread
run in an infinite loop in which it does the re-init and then goes to sleep
for one second on each iteration. That would allow it to re-initialize your
buffer every second as you want, without the need for creating/destroying a
new thread every time.

Alternatively, why use another thread at all. Another thread
means that all accesses will have to be locked, etc. Depending
on the exact application, it might be simpler to just position a
time stamp each time he initializes the buffer, and check the
time stamp and do the reinitializatio n each time he uses it.

Of course, if the "reinitializati on" is really an update of real
time data, which the main thread is reading, and the update
takes a significant amount of time, then there can be problems
of latency. In that case, he probably needs a pair of buffers,
the reading thread uses one, the writing thread the other, and
the writing thread swaps them when it finishes an update. (One
of the applications I'm currently working on does this, except
that the reader isn't a different thread, it's a different
process, and the buffers are in shared memory.)

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34

On Dec 1, 8:01 pm, christian.si... @gmail.com wrote:

Hello,

I need a buffer reinitialized approx. once in each second (I think
this is quite often). Now I think to do the reinit within a separate
thread (I am using boost::thread). Well, filling the buffer is a real
short task but must be done very often (at least once in a second).

So what is the guide line how often a thread should be created and how
long it should last???

Thanks for your help
Chris

You can use single thread which waits for a semaphore
( thread safe counting value wrapped so your thread will sleep until
another thread changes the value)
When you need reinitializing a buffer, you can post the semaphore to
allow waiting thread to reinitialize
the buffer ( protected by some mutex)