From: bill_kempf (williamkempf_at_[hidden])
Date: 2002-03-04 07:59:23
--- In boost_at_y..., "Yitzhak Sapir" <ysapir_at_y...> wrote:
> I want to initialize a "singleton" type object. To do this, I use
> call_once.
>
> void f()
> {
> call_once(inited, init_singleton);
> }
>
> basically. Now, after I init it, I want to use it in some way. So
then
> I have:
>
> void f()
> {
> call_once(inited, init_singleton);
> use_singleton();
> }
>
> Now, I was thinking that call_once may be called in a different
thread
> already by the time I get to use_singleton, but the singleton has
not
> been inited yet. So I added a mutex:
>
> void f()
> {
> call_once(inited, init_singleton);
> scoped_lock(singleton_mutex);
> use_singleton();
> }
>
> init_singleton()
> {
> scoped_lock(singleton_mutex);
> // do initialization
> }
>
> (I look at this now and am thinking this only reduces the possible
race
> condition but may, depending on the implementation of call_once, not
> eliminate it entirely). Now I want to call f() in a global
variable:
>
> struct some_global
> {
> some_global() { f(); }
> };
>
> some_global a_global;
>
> Now I have a worse condition, in which case the mutex, which is also
> global, may be constructed after the global. In this case, during
> call_once() in the call to f(), I'd end up waiting on a mutex that
> hasn't been constructed inside the scoped_lock. I could use
call_once
> to initialize the mutex, but I'd have to know what guarantees are
made
> regarding call_once to know if it solves the problem.
Particularly, I
> need to know, not only that "flag != once_init" is a postcondition
of
> call_once, but also that func() has completed execution. So, given
that
> I still have a race condition in the previous step, and given this
issue
> of unclear order of global initializations, how would it be best to
> solve this problem, or does call_once indeed guarantee this
> postcondition ("func() has executed at least one time.")?
The gaurantee is that "func() has been executed exactly once". It
must have been run before call_once() will return, and it will only
run once. As you note, any other gaurantees are not useful. I
thought the documentation was explicit about this, but I'll look at
it while I'm reworking the documentation.
> Btw, this may be the time to point out that the docs at
> http://www.boost.org/libs/thread/doc/call_once.html specify a const
> once_flag once_init, whereas the actual thing to document is: const
> once_flag BOOST_ONCE_INIT;
This is something that changed at one point, and I thought I had
gotten the documentation up to date with the code. I'll have to fix
this as well.
Thanks,
Bill Kempf