---------------
// dodaje jeden do x:
    zaadowanie x do elementu pamici podrcznej Cx
    zaadowanie Cx do rejestru Rx
    Rx=Rx+1;
    zapisanie Rx z powrotem w Cx
    zapisanie Cx z powrotem w x
---------------
// wtek 1:                    // wtek 2:
    char c = 0;               char b = 0;
    void f()                  void g()
    {                         {
        c=1;                      b=1;
        int x = c;                int y = b;
     }                        }
---------------
struct S {
    char a;                 // lokalizacja 1
    int b:5;                // lokalizacja 2
    unsigned c:11;
    unsigned :0;            // uwaga: :0 jest specjalnym przypadkiem (8.2.7)
    unsigned d:8;           // lokalizacja #3
    struct { int ee:8; } e; // lokalizacja #4
};
---------------
// wtek 1:
    int x;
    bool x_init;

    void init()
    {
        x = initialize(); // zmienna x_init nie jest uywana w initialize()
        x_init = true;
        //...
}
---------------
// wtek 2:
    extern int x;
    extern bool x_init;

    void f2()
    {
        int y;
        while (!x_init) // w razie potrzeby poczekaj na zakoczenie inicjacji
            this_thread::sleep_for(milliseconds{10});
    y=x;
    //...
}
---------------
// wtek 1:                     // wtek 2:
    char c = 0;                 char b = 0;
    extern char b;              extern char c;
    void f1()                   void f2()
    {                           {
        c=1;                         b=1;
        int x = b;                   int y = c;
    }                            }
---------------
c=1;     b=1;     c=1;
x=b;     y=c;     b=1;
b=1;     c=1;     x=b;
y=c;     x=b;     y=c;
---------------
enum memory_order {
    memory_order_relaxed,
    memory_order_consume,
    memory_order_acquire,
    memory_order_release,
    memory_order_acq_rel,
    memory_order_seq_cst
};
---------------
// wtek 1:
r1 = y.load(memory_order_relaxed);
x.store(r1,memory_order_relaxed);

// wtek 2:
r2 = x.load(memory_order_relaxed);
y.store(42,memory_order_relaxed);
---------------
y.store(42,memory_order_relaxed);
r1 = y.load(memory_order_relaxed);
x.store(r1,memory_order_relaxed);
r2 = x.load(memory_order_relaxed);
---------------
[[carries_dependency]] struct foo *f(int i)
{
    // niech wywoujcy uyje memory_order_consume dla wyniku:
    return foo_head[i].load(memory_order_consume);
}
---------------
template<typename T>
class shared_ptr {
public:
    //...
    ~shared_ptr()
    {
        if (--*puc) delete p;
    }
private:
    T* p;             // wskanik do wsplnego obiektu
    atomic<int>* puc; // wskanik do licznika uy
};
---------------
atomic<int> val = 0;
//...
int expected = val.load();     // wczytuje biec warto
do {
    int next = fct(expected);  // oblicza now warto
} while (!val.compare_exchange_weak(expected,next)); // zapisuje next do val lub expected
---------------
extern atomic<Link*> head;          // wspdzielony pocztek listy powizanej

Link* nh = new Link(data,nullptr);  // przygotowanie cza do wstawiania
Link* h = head.load();              // wczytuje wspdzielony pocztek listy
do {
    if (h->data<data) break;        // jeli tak, wstawia gdzie indziej
    nh->next = h;                   // nastpny element jest tym, ktry poprzednio by pierwszy
} while (!head.compare_exchange_weak(h,nh)); // zapisuje nh na pocztku albo do h
---------------
X x;                         // potrzebna jest blokada do inicjacji X
mutex lx;                    // muteks do blokowania x podczas inicjacji
atomic<bool> x_init {false}; // konstrukcja atomowa pozwalajca zminimalizowa blokowanie

void some_code()
{
    if (!x_init) {     // kontynuuje, jeli x jest niezainicjowana
        lx.lock();
        if (!x_init) { // kontynuuje, jeli x jest nadal niezainicjowana
            //... inicjuje x...
            x_init = true;
        }
        lx.unlock();
    }
    //... uywa x...
}
---------------
class spin_mutex {
    atomic_flag flag = ATOMIC_FLAG_INIT;
public:
    void lock() { while(flag.test_and_set()); }
    void unlock() { flag.clear(); }
};
---------------
volatile const long clock_register;  // aktualizacja przez zegar sprztowy
---------------
auto t1 {clock_register};
//... clock_register nie jest tu uywana...
auto t2 {clock_register};