The completions
of the destructors for all initialized objects with thread storage duration within that thread are sequenced
before the initiation of the destructors of any object with static storage duration.

#include <thread>
#include <atomic>
#include <chrono>
#include <iostream>

thread_local struct Z
{
    ~Z()
    {
         std::cout << "Destroyed Z\n";
    }

    void f() {}
} z;

static struct X
{
    X(): thd([this]
        {
            while ( ! stop.load() )
                std::this_thread::sleep_for(std::chrono::milliseconds(200));
            z.f();
        })
    {
        z.f();
    }

    ~X()
    {
        std::cout << "Destroying X\n";
        stop.store(true);
        thd.join();
        std::cout << "Destroyed X\n";
    }
    
    std::atomic_bool stop;
    std::thread thd;
} x;

int main()
{
    std::cout << "Exiting\n";
    return 0;
}

#include <iostream>
using namespace std;

int g_tab = 1;
struct X {
    int tab;
    const char* name;
    X(const char* name) : name(name), tab(g_tab++) {
        cout << string(tab, '\t') << name << " : ctor" << endl;
    }
    ~X() {
        cout << string(tab, '\t') << name << " : dtor" << endl; }
};

X g1("g1");
thread_local X t1("t1");
thread_local X t2("t2");
X g2("g2");

int main() {
    cout << "start!" << endl;
    static X s1("s1");
    cout << "test " << t1.name << endl;  // первое обращение к TLS провоцирует инициализацию всех TLS-объектов
    static X s2("s2");
    cout << "finish!" << endl;
}

    g1 : ctor
        g2 : ctor
start!
            s1 : ctor
                t1 : ctor
                    t2 : ctor
test t1
                        s2 : ctor
finish!
                    t2 : dtor
                t1 : dtor
                        s2 : dtor
            s1 : dtor
        g2 : dtor
    g1 : dtor

#include <iostream>
#include <string>
using namespace std;
 
int g_tab = 1;
struct X {
    int tab;
    const char* name;
    X(const char* name) : name(name), tab(g_tab++) {
        cout << string(tab, '\t') << name << " : ctor" << endl;
    }
    ~X() {
        cout << string(tab, '\t') << name << " : dtor" << endl; }
};
 
struct Y {
    Y() {
        static X s2("s2");
    }
};
 
Y y;
 
X g1("g1");
X g2("g2");
 
 
int main() {
    cout << "start!" << endl;
    static X s1("s1");
    cout << "finish!" << endl;
}

    s2 : ctor
        g1 : ctor
            g2 : ctor
start!
                s1 : ctor
finish!
                s1 : dtor
            g2 : dtor
        g1 : dtor
    s2 : dtor

3.6.2 Initialization of non-local variables [basic.start.init]

4
It is implementation-defined whether the dynamic initialization of a non-local variable with static storage
duration is done before the first statement of main. If the initialization is deferred to some point in time
after the first statement of main, it shall occur before the first odr-use (3.2) of any function or variable
defined in the same translation unit as the variable to be initialized.
[ Example:

// - File 1 -
#include "a.h"
#include "b.h"
B b;
A::A(){
b.Use();
}
// - File 2 -
#include "a.h"
A a;
// - File 3 -
#include "a.h"
#include "b.h"
extern A a;
extern B b;
int main() {
a.Use();
b.Use();
}

It is implementation-defined whether either a or b is initialized before main is entered or whether the
initializations are delayed until a is first odr-used in main. In particular, if a is initialized before main is
entered, it is not guaranteed that b will be initialized before it is odr-used by the initialization of a, that is,
before A::A is called. If, however, a is initialized at some point after the first statement of main, b will be
initialized prior to its use in A::A. — end example ]

5
It is implementation-defined whether the dynamic initialization of a non-local variable with static or thread
storage duration is done before the first statement of the initial function of the thread. If the initialization
is deferred to some point in time after the first statement of the initial function of the thread, it shall occur
before the first odr-use (3.2) of any variable with thread storage duration defined in the same translation
unit as the variable to be initialized.

static GlobalData g_GlobalData;
static thread_local ThreadData g_ThreadData; // ThreadData использует g_GlobalData

std::shared_ptr<GlobalData> GetGlobalData() 
{
   static auto instance = std::make_shared<GlobalData>();
   return instance;
}

static thread_local ThreadData g_ThreadData; // ThreadData в своём конструкторе сохраняет у себя результат GetStaticData()

AG>static GlobalData g_GlobalData;
AG>static thread_local ThreadData g_ThreadData; // ThreadData использует g_GlobalData

#include <thread>
#include <atomic>
#include <chrono>
#include <iostream>

void do_stop();

thread_local struct Z {
    ~Z() { std::cout << "Destroyed Z\n"; }
    void f() {}
} z;

static struct X {
    X(): thd([this] {
            while ( ! stop.load() )
                std::this_thread::sleep_for(std::chrono::milliseconds(200));
            z.f();  }) {
       std::atexit(do_stop);
       z.f();
    }

    void stop() {
        std::cout << "Destroying X\n";
        stop.store(true);
        thd.join();
        std::cout << "Destroyed X\n";
    }
    
    std::atomic_bool stop;
    std::thread thd;
} x;

void do_stop() {
    x.stop();
}

int main() {
    std::cout << "Exiting\n";
    return 0;
}

// static X x (a,b,c);

using X_Data = aligned_storage<sizeof(X), alignof(X)>::type;

static X_Data x_data;
static bool x_created = false;

static X& x = (X&)x_data;

void touch_x() {
  if (!x_created) {  // сейчас не будем морочить себе голову вопросами реентера и многопоточности
    new (&x) X(a,b,c);
    atexit(kill_x);
    x_created = true;
  }
}
void kill_x() {
  if (x_created)
    x.~X();
}

X& take_x() { touch_x(); return x; }

//////// зависимый от него static Y y(x);

void touch_y() {
  if (!y_created) {
    new (&y) Y(take_x()); // в рамках take_x -> touch_x мы добавим kill_x
    atexit(kill_y);       // вперёд добавления kill_y
    y_created = true;
  }
}

#include <iostream>
using namespace std;

struct X
{
    ~X() { std::cout << "3\n";  }
    
    void f() {}
} x;


struct Y
{
    ~Y() 
    {
        static struct Z 
        {
            ~Z() 
            {
                //x.f();
                std::cout << "2\n";
            } 
        } z;
        
        std::cout << "1\n";  
    }
} y;

int main() 
{
    return 0;
}