Is static memory cleaned up by a different thread?

So, what happened in my project was the following:

I have a singleton which is defined in a usual way:

Singleton* Singleton::getInstance()
{
  static Singleton instance;
  return &instance;
}

in its constructor, this singleton object initializes a CORBA ORB and started running it in a separate (boost)thread(wrapper) similar to this:

CorbaController::CorbaController()
{
}

CorbaController::~CorbaController()
{
    if(!CORBA::is_nil(_orb))
        _orb->shutdown(true);
}

void CorbaController::run()
{
    _orb->run();
}

bool CorbaController::initCorba(const std::string& ip, unsigned long port)
{
    // init CORBA
    // ...

    // let the ORB execute in a dedicated thread since the run operation is blocking
    start();

    return true;
}

Now the normal behavior when destructing the CorbaController is that it calls shutdown on the ORB in its destructor, the run method then jumps out of orb.run() and finishes the separate thread. However this only works if the CorbaController is deleted explicitly or defined as a local or class variable which then runs out of scope at some point. If I rely on the singleton's static variable being cleaned up at the end of the program though, the orb.shutdown() deadlocks because the ACE/TAO lib can't aquire a semaphore on some object to be destructed with the ORB shutdown.

Does anybody have an idea of what might be the problem here? Can this be a threading problem, i.e. that the thread which constructrs the singleton (and also runs the main function of my application) is different from the thread cleaning up static memory instances?

You have to shuytdown and destroy the ORB during the regular shutdown of the application, doing it in the destructor of a static object is really too late. Add a shutdown() method to your CORBA Controller which does a shutdown and destroy of the ORB.